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")
}

• The output is the source of normalize_file(ast): exposed items and imports in elm-format's order, elm-format's parentheses and literal forms, and doc comments with their Markdown and Elm code formatted.
• Every regular comment prints once, where elm-format puts it: a comment leads the node after it, trails the node before it on its line, or goes before the closing token of its container. A comment moves with an exposed item or an import that elm-format reorders. A block comment gets elm-format's form ({-a-} gives {- a -}). No comment is dropped: one that the printer cannot place raises Unprintable with UnplacedComment.
• Raises ParseFailed when the source has a syntax error in dialect.

test {
  let source = "module A exposing (a)\n\na = f x -- why\n  y\n"
  inspect(
    @printer.format(source),
    content=(
      #|module A exposing (a)
      #|
      #|
      #|a =
      #|    f x
      #|        -- why
      #|        y
      #|
    ),
  )
}

test {
  let result = @parser.parse_module(
    @scanner.SourceText::new("module A exposing (a)\n\na = [1,2]\n"),
    @scanner.DefaultScanner::new(),
  )
  inspect(
    @printer.format_parsed(result, layout=Width(40)),
    content=(
      #|module A exposing (a)
      #|
      #|
      #|a =
      #|    [ 1, 2 ]
      #|
    ),
  )
}

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\"]")
}

• The module's exposed items are a set: a duplicate is removed (T and T(..) give T(..)). They are sorted: operators, then types, then values, each by name. When the module documentation has @docs lines, the items that they name come first, in the order of those lines.
• The imports are sorted by module name. The imports of one module are merged into the first: a later alias replaces an earlier one, and the exposing lists are joined ((..) wins). An alias equal to the module name is removed (import A as A). Each exposing list is a sorted set, as above.
• Parentheses that neither the parser nor elm-format needs go (elm-format formatExpression, syntaxParens): case (f x) of gives case f x of, a - (f b) gives a - f b, f (-x) gives f -x. Parentheses around an operator chain in a chain stay.
• Parentheses are added where print_file writes them: elm-format's, around a lambda, if, case or let at the end of an operator chain, except after <| (x |> (\y -> y)), and around a constructor pattern with arguments before or after :: and in an as ((Just a) :: rest); and the ones that the parser needs, for example around an operator chain that cannot join its parent's chain ((a + b) * c).

• Doc comments (documentation and the doc comments in File.comments) are written as elm-format writes them: Markdown through @markdown.format_doc, Elm code in them formatted (see format). As elm-format, this is not idempotent for some doc comments: @docsT(..) (it names no exposed item, then it names T(..) as T), emphasis that starts after a letter (a*b c* gives a_b c_, then text), two bullet lists in a row (one list the next time), [a] [a] (one link), and a fenced Elm code block that starts with a blank line (the line goes the next time).

test {
  let text = "module A exposing (b, a)\n\nimport C\nimport B as B\n\n\na =\n    1\n"
  let file = @parser.parse_module(
    @scanner.SourceText::new(text),
    @scanner.DefaultScanner::new(),
  ).ast.unwrap()
  inspect(
    @printer.print_file(@printer.normalize_file(file)),
    content=(
      #|module A exposing (a, b)
      #|
      #|import B
      #|import C
      #|
      #|
      #|a =
      #|    1
      #|
    ),
  )
}

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
    ),
  )
}