moonscript.peg

{
package main
}

Input <- lines:Lines? White EOF {
  return toValue[Lines](lines), nil
}

EOF <- !.
White <- [ \t\r\n]* // includes newlines
Space <- [ \t]*
SomeSpace <- [ \t]+
Break <- "\r"? "\n"
Stop <- Break / EOF
SpaceBreak <- Space Break
AlphaNum <- [a-zA-Z0-9_]

Lines <- EmptyLine* StartIndent head:Line tail:LinesTail* PopIndent {
  lines := make([]any, 0, 1)
  if head != nil {
    lines = append(lines, head)
  }

  for _, t := range tail.([]any) {
    if t == nil {
      continue
    }

    lines = append(lines, t)
  }

  return Lines{lines}, nil
}

LinesTail <- Space Break EmptyLine* line:IndentedLine {
  return line, nil
}

Line <- CommentLine / AssignmentLine / ReturnStatement / FlowControl/ ControlStatement / ExpressionLine
ControlStatement <- IfStatement / WhileStatement / ForLoop / ForEachLoop

IndentedLine <- MatchIndent line:Line {
  return line, nil
}

Keyword <- "if" / "then" / "elseif" / "else" / "return" / "function" / "and" / "or" / "continue" / "break"

FlowControl <- "continue" { return FlowControlNode{Continue}, nil } / "break" { return FlowControlNode{Break}, nil }

EmptyLine <- Space Break {
  return nil, nil
}

// for when we need to coerce expressions into lines
ExpressionLine <- Expression

Expression <- head:ExpressionValue rest:OperatorExpression* {
  r := make([]OperatorExpressionNode, 0, len(rest.([]any)))

  for _, exp := range rest.([]any) {
    r = append(r, exp.(OperatorExpressionNode))
  }

  // remove unec
  if len(r) == 0 {
    return head, nil
  }

  return ExpressionNode{head, r}, nil
}

OperatorExpression <- Space operator:Operator White exp:ExpressionValue {
  return OperatorExpressionNode{operator.(string), exp}, nil
}

ExpressionValue <- Primitive / Number / Chain / Ref / String / Table / Parens / FunctionExpression

Parens <- "(" White exp:Expression White ")" {
  return ParensNode{exp}, nil
}

ExpressionList <- head:Expression tail:ExpressionListTail* {
  exprs := make([]any, 0, 1)
  exprs = append(exprs, head)
  for _, t := range tail.([]any) {
    exprs = append(exprs, t)
  }

  return ExpressionList{exprs}, nil
}

ExpressionListTail <- Space "," White expr:Expression {
  return expr, nil
}

Operator <- ([-+*/^%<>] / WordOperator) {
  return string(c.text), nil
}

WordOperator <- ("and" / "or") !AlphaNum / ".."

AssignmentLine <- names:NameList White "=" White exprs:ExpressionList {
  return AssignmentNode{names.([]any), exprs.(ExpressionList)}, nil
}

Comment <- "--" body:CommentBody {
  return CommentNode{body.(string)}, nil
}

// a comment that takes up an entire line
CommentLine <- Space value:Comment {
  return value, nil
}

CommentBody <- (!Break .)* {
  return string(c.text), nil
}

Name <- [a-zA-Z_] [a-zA-Z0-9_]* {
  return string(c.text), nil
}

NameListTail <- Space "," White name:Name {
  return name, nil
}

NameList <- head:Name tail:NameListTail* {
  names := make([]any, 0, 1)
  names = append(names, head)
  for _, t := range tail.([]any) {
    names = append(names, t)
  }

  return names, nil
}

Ref <- !(Keyword !AlphaNum) name:Name {
  return RefNode{name.(string)}, nil
} / SelfRef / Self

SelfRef <- "@" name:Name {
  return SelfRefNode{name.(string)}, nil
}

Self <- "@" {
  return RefNode{"self"}, nil
}

// TODO: handle decimals and exponents (non integer types
Number <- [0-9]+ {
  return NumberNode{Integer, string(c.text)}, nil
}

String <- DoubleQuotedString / SingleQuotedString / LuaString

DoubleQuotedString <- '"' parts:(Interpolation / DoubleStringChars)* '"' {
  return StringNode{`"`, parts.([]any)}, nil
}

DoubleStringChars <- ([\\] '"' / !["] !"#{" .)+ {
  return string(c.text), nil
}

Interpolation <- "#{" expr:Expression "}" {
  return InterpolationNode{expr}, nil
}

SingleQuotedString <- "'" parts:(SingleStringChars)* "'" {
  return StringNode{`'`, parts.([]any)}, nil
}

SingleStringChars <- ([\\] "'" / !"'" .)+ {
  return string(c.text), nil
}

LuaString <- LuaStringOpen parts:(LuaStringChars)* LuaStringClose {
  return StringNode{"XXX", parts.([]any)}, nil
}

LuaStringChars <- (!LuaStringClose .)+ {
  return string(c.text), nil
}

LuaStringDelimiterCount <- "="* {
  return len(c.text), nil
}

LuaStringOpen <- "[" count:LuaStringDelimiterCount "[" #{
  c.state["lua_string"] = count
  return nil
}

LuaStringClose <- "]" count:LuaStringDelimiterCount "]" &{
  if c.state["lua_string"].(int) == count.(int) {
    return true, nil
  }

  return false, nil
}

Primitive <- ("true" / "false" / "nil") {
  return PrimitiveNode{string(c.text)}, nil
}

Table <- "{" White tuples:TableElementList? White "}" {
  if tuples == nil {
    return TableNode{nil}, nil
  } else {
    return TableNode{tuples.([]TableTuple)}, nil
  }
}

TableElementList <- head:TableElement tail:TableElementTail* {
  tuples := make([]TableTuple, 0, 1)
  tuples = append(tuples, head.(TableTuple))
  for _, t := range tail.([]any) {
    tuples = append(tuples, t.(TableTuple))
  }

  return tuples, nil
}

TableElement <- el:(TableTuple / Expression) {
  switch el.(type) {
  case TableTuple:
    return el, nil
  default:
    // convert single value into table tuple
    return TableTuple{nil, el}, nil
  }
}

TableTuple <- name:(Name / TableTupleKeyExpression ) ":" White exp:Expression {
  return TableTuple{name, exp}, nil
}

TableTupleKeyExpression <- "[" White exp:Expression White "]" {
  return exp, nil
}

TableElementTail <- Space ("," / Break ) White el:TableElement {
  return el, nil
}

Chain <- target:(Ref / Parens) tail:ChainOperation+ {
  return ChainNode{target, tail.([]any)}, nil
}

ChainOperation <- ChainBang / ChainCall / ChainDot / ChainMethod / ChainCallParens / ChainIndex

// whitespace function call
ChainCall <- SomeSpace args:ExpressionList {
  return ChainCallNode{args.(ExpressionList)}, nil
}

ChainBang <- "!" {
  return ChainCallNode{}, nil
}

ChainCallParens <- "(" White args:ExpressionList White ")" {
  return ChainCallNode{args.(ExpressionList)}, nil
}

ChainDot <- "." White name:Name {
  return ChainDotNode{name.(string)}, nil
}

ChainMethod <- `\` White name:Name {
  return ChainMethodNode{name.(string)}, nil
}

ChainIndex <- "[" White exp:Expression White "]" {
  return ChainIndexNode{exp}, nil
}

Indent <- [ \t]* {
  str := string(c.text)
  sum := 1 * strings.Count(str, " ") + 4 * strings.Count(str, "\t")
  return sum, nil
}

StartIndent <- indent:Indent &{
  if currentIndent(c.state) < indent.(int) {
    return true, nil
  }
  return false, nil
} #{
  pushIndent(c.state, indent.(int))
  return nil
}

// measure the indent and only pass if it matches the current indent
MatchIndent <- indent:Indent &{
  if currentIndent(c.state) == indent.(int) {
    return true, nil
  }
  return false, nil
}

PopIndent <- #{
  popIndent(c.state)
  return nil
}

ReturnStatement <- "return" exprs:ReturnExpressionList? {
  return ReturnNode{toValue[ExpressionList](exprs)}, nil
}

ReturnExpressionList <- Space exprs:ExpressionList {
  return exprs, nil
}

IfStatement <- "if" Space
  condition:Expression Space
  lines:(ConditionLine / ConditionBlock)
  else_if_blocks:ElseIfBlock*
  else_lines:(ElseBlock / ElseLine)?
  {
    return IfStatementNode{
      condition,
      lines.(Lines),
      toSlice[ElseIfStatementNode](else_if_blocks),
      toValue[Lines](else_lines),
    }, nil
  }

ConditionLine <- "then" Space line:Line {
  return Lines{[]any{line}}, nil
}

ConditionBlock <- Break lines:Lines {
  return lines, nil
}

ElseIfBlock <- SpaceBreak MatchIndent "elseif" Space condition:Expression SpaceBreak lines:Lines {
  return ElseIfStatementNode{condition, lines.(Lines)}, nil
}

ElseBlock <- SpaceBreak MatchIndent "else" SpaceBreak lines:Lines {
  return lines, nil
}

ElseLine <- White "else" Space line:Line {
  return Lines{[]any{line}}, nil
}

FunctionExpression <- args:FunctionArguments? Space isMethod:FunctionType lines:(FunctionBlock / FunctionLine)? {
  return FunctionExpressionNode{
    isMethod.(bool),
    toSlice[ArgumentTuple](args),
    toValue[Lines](lines),
  }, nil
}

FunctionType <- "->" { return false, nil} / "=>" { return true, nil}


FunctionBlock <- SpaceBreak lines:Lines {
  return lines, nil
}

FunctionLine <- Space line:Line {
  return Lines{[]any{line}}, nil
}


FunctionArguments <- "(" Space names:NameList? Space ")" {
  strNames := toSlice[string](names)

  if strNames == nil {
    return nil, nil
  }

  tuples := make([]ArgumentTuple, 0, len(strNames))

  for _, name := range strNames {
    tuples = append(tuples, ArgumentTuple{name, nil})
  }

  return tuples, nil
}

WhileStatement <- "while" Space condition:Expression SpaceBreak lines:Lines {
  return WhileStatementNode{
    condition,
    lines.(Lines),
  }, nil
}

ForLoop <- "for" Space variable:Name Space "=" Space start:Expression Space "," Space end:Expression step:ForLoopStep? SpaceBreak lines:Lines {
  return ForLoopNode{
    variable,
    start,
    end,
    step,
    lines.(Lines),
  }, nil
}

ForLoopStep <- Space "," Space step:Expression {
  return step, nil
}


ForEachLoop <- "for" Space names:NameList Space "in" Space exprs:ExpressionList SpaceBreak lines:Lines {
  return ForEachLoopNode{
    names.([]any),
    exprs.(ExpressionList),
    lines.(Lines),
  }, nil
}