struct Names {
  functions : Array[String]
  mut patterns : Int
}

impl @syntax.Visitor for Names with fn visit_function(self, n) {
  match n {
    Declaration({ value: FunctionDeclaration(f), .. }, _) =>
      self.functions.push(f.declaration.value.name.value)
    _ => ()
  }
  Continue
}

impl @syntax.Visitor for Names with fn visit_pattern(self, _) {
  self.patterns  1
  Continue
}

test {
  let src = "module Main exposing (..)\n\nadd x y =\n    x + y\n\nz = 0\n"
  let result = @parser.parse_module(
    @scanner.SourceText::new(src),
    @scanner.DefaultScanner::new(),
  )
  let root = @syntax.NodeRef::of_result(result).unwrap()
  let names = { functions: [], patterns: 0, }
  @syntax.accept(root, names)
  debug_inspect(names.functions, content="[\"add\", \"z\"]")
  inspect(names.patterns, content="2")
}

test {
  inspect(
    @krueger.diagnostic_description("KR-SCAN-004").unwrap_or("?"),
    content="Unterminated string, char or GLSL literal",
  )
  debug_inspect(@krueger.diagnostic_description("KR-NONE"), content="None")
}

test {
  let text =
    #|module Main exposing (x)
    #|
    #|{-| Answers.
    #|
    #|@since 2
    #|-}
    #|x = 42
    #|
  let source = @scanner.SourceText::new(text)
  let result = @parser.parse_module(source, @scanner.DefaultScanner::new())
  // The first doc comment documents the module.
  let json = @parser.encode_attributes(result.attributes)
  inspect(
    json.stringify(),
    content=(
      #|[{"target":"module","attributes":[{"name":{"range":[5,2,5,7],"value":"since"},"arguments":[{"range":[5,8,5,9],"value":{"type":"integer","integer":2}}],"range":[5,1,5,9]}]}]
    ),
  )
}

test {
  let text =
    #|module Main exposing (x)
    #|
    #|{-| Ids.
    #|
    #|@id 9007199254740993
    #|-}
    #|x = 1
    #|
  let source = @scanner.SourceText::new(text)
  let groups = @parser.parse_module(source, @scanner.DefaultScanner::new()).attributes
  let exact = @parser.encode_attributes_with(groups, exact_ints=true).stringify()
  inspect(exact.contains("9007199254740993"), content="true")
  let nearest = @parser.encode_attributes(groups).stringify()
  inspect(nearest.contains("9007199254740993"), content="false")
}

test {
  let source = @scanner.SourceText::new(
    "module Main exposing (..)\n\nmain =\n    (1 + 2\n",
  )
  let result = @parser.parse_module(source, @scanner.DefaultScanner::new())
  let json = @report.encode_diagnostics(result.diagnostics)
  inspect(
    json.stringify(),
    content=(
      #|[{"code":"KR-PARSE-004","severity":"error","title":"UNFINISHED PARENTHESES","message":"Malformed function declaration: expected `,` or `)`, found end of input","span":{"start":{"line":4,"column":11},"end":{"line":4,"column":11}}}]
    ),
  )
}

test {
  let src = "module Main exposing (..)\n\nadd x y =\n    x + y\n"
  let result = @parser.parse_module(
    @scanner.SourceText::new(src),
    @scanner.DefaultScanner::new(),
  )
  let root = @syntax.NodeRef::of_result(result).unwrap()
  // Count the expressions and find the deepest nesting.
  let (count, _, deepest) = @syntax.fold(
    root,
    (0, 0, 0),
    (acc, n) => {
      let (count, depth, deepest) = acc
      let count = count + (if n.category() == "expression" { 1 } else { 0 })
      let depth = depth + 1
      let deepest = if depth > deepest { depth } else { deepest }
      ((count, depth, deepest), Continue)
    },
    leave=(acc, _) => (acc.0, acc.1 - 1, acc.2),
  )
  inspect(count, content="3")
  inspect(deepest, content="5")
}

test {
  inspect(@scanner.is_lower_start('a'), content="true")
  inspect(@scanner.is_lower_start('é'), content="true")
  inspect(@scanner.is_lower_start('A'), content="false")
  inspect(@scanner.is_lower_start('_'), content="false")
}

test {
  inspect(@scanner.is_name_part('x'), content="true")
  inspect(@scanner.is_name_part('_'), content="true")
  inspect(@scanner.is_name_part('7'), content="true")
  inspect(@scanner.is_name_part('ß'), content="true")
  inspect(@scanner.is_name_part('-'), content="false")
  inspect(@scanner.is_name_part('\''), content="false")
}

test {
  inspect(@scanner.is_upper_start('M'), content="true")
  inspect(@scanner.is_upper_start('Ä'), content="true")
  inspect(@scanner.is_upper_start('Dž'), content="true")
  inspect(@scanner.is_upper_start('m'), content="false")
}

test {
  let rows = @syntax.kind_table()
  let row = rows.filter(r => r.0 == "expression" && r.1 == "ifBlock")[0]
  debug_inspect(row.2, content="[\"clause\", \"then\", \"else\"]")
  // `list` is a kind of both expressions and patterns.
  let lists = rows.filter(r => r.1 == "list").map(r => r.0)
  debug_inspect(lists, content="[\"expression\", \"pattern\"]")
}

test {
  let source = @krueger.SourceText::new(
    "module Main exposing (main)\n\nmain =\n    1 + 2\n",
  )
  let result = @krueger.parse_module(source)
  inspect(result.diagnostics.length(), content="0")
  guard result.ast is Some(file) else { fail("no AST") }
  guard file.declarations[0].value is FunctionDeclaration(f) else {
    fail("not a function")
  }
  inspect(f.declaration.value.name.value, content="main")
  debug_inspect(
    f.declaration.value.name.range,
    content="{ start: { row: 3, column: 1 }, end: { row: 3, column: 5 } }",
  )
}

test {
  let source = @krueger.SourceText::new(
    "module Main exposing (..)\n\nmain =\n    (1 + 2\n\nother = 3\n",
  )
  let result = @krueger.parse_module(source)
  let d = result.diagnostics[0]
  inspect(d.code, content="KR-PARSE-004")
  inspect(d.title, content="UNFINISHED PARENTHESES")
  debug_inspect(d.severity, content="Error")
  // The declaration after the error still parses.
  guard result.ast is Some(file) else { fail("no AST") }
  inspect(file.declarations.length(), content="1")
}

test {
  let source = @krueger.SourceText::new(
    "module Main exposing (..)\n\nx =\n    007\n",
  )
  let strict = @krueger.parse_module(source)
  inspect(
    strict.diagnostics[0].message,
    content="Malformed function declaration: numbers cannot start with zeros [rule: leading-zero]",
  )
  let lenient = @krueger.parse_module(
    source,
    dialect=@krueger.Dialect::elm_syntax_7_3_9(),
  )
  inspect(lenient.diagnostics.length(), content="0")
}

test {
  let dialect = @krueger.Dialect::elm_0_19_1()
  let source = @krueger.SourceText::new("module Main exposing (..)\n\nx = 1\n")
  guard @krueger.tokenize(source, dialect~) is Ok(tokens) else {
    fail("scan error")
  }
  let result = @krueger.parse_tokens(tokens, dialect~)
  inspect(result.diagnostics.length(), content="0")
  inspect(result == @krueger.parse_module(source, dialect~), content="true")
}

test {
  let r : @ast.Range = {
    start: { row: 0, column: 0, },
    end: { row: 0, column: 0, },
  }
  let int : @ast.Node[@ast.TypeAnnotation] = {
    range: r,
    value: Typed({ range: r, value: ([][:], "Int"), }, [][:]),
  }
  let decl : @ast.Node[@ast.Declaration] = {
    range: r,
    value: AliasDeclaration({
      documentation: None,
      name: { range: r, value: "Age", },
      generics: [][:],
      type_annotation: int,
    }),
  }
  inspect(
    @printer.print_declaration(decl),
    content=(
      #|type alias Age =
      #|    Int
    ),
  )
}

test {
  let r : @ast.Range = {
    start: { row: 0, column: 0, },
    end: { row: 0, column: 0, },
  }
  fn v(name : String) -> @ast.Node[@ast.Expression] {
    { range: r, value: FunctionOrValue([][:], name), }
  }
  let sum : @ast.Node[@ast.Expression] = {
    range: r,
    value: OperatorApplication("+", Left, v("a"), v("b")),
  }
  let product : @ast.Node[@ast.Expression] = {
    range: r,
    value: OperatorApplication("*", Left, sum, v("c")),
  }
  inspect(@printer.print_expression(product), content="(a + b) * c")
}

test {
  let text = "module Main exposing (main)\n\n\nmain =\n    1 + 2\n"
  let result = @parser.parse_module(
    @scanner.SourceText::new(text),
    @scanner.DefaultScanner::new(),
  )
  inspect(@printer.print_file(result.ast.unwrap()) == text, content="true")
}

test {
  let r : @ast.Range = {
    start: { row: 0, column: 0, },
    end: { row: 0, column: 0, },
  }
  fn pvar(name : String) -> @ast.Node[@ast.Pattern] {
    { range: r, value: VarPattern(name), }
  }
  let inner : @ast.Node[@ast.Pattern] = {
    range: r,
    value: UnConsPattern(pvar("a"), pvar("b")),
  }
  let outer : @ast.Node[@ast.Pattern] = {
    range: r,
    value: UnConsPattern(inner, pvar("rest")),
  }
  // `::` is right-associative, so an `::` on its left gets parentheses.
  inspect(@printer.print_pattern(outer), content="(a :: b) :: rest")
}