@ttsc/lint 0.12.3 → 0.13.0

package/linthost/print_nodes_call.go

@@ -20,17 +20,23 @@ import (
 // Type arguments (`foo<A, B>(x)`) are preserved verbatim. Trailing
 // commas on type arguments are intentionally avoided — Prettier omits
 // them too (see prettier#10353).
-func printCallExpression(ctx *PrintContext, node *shimast.Node) Doc {
+//
+// The second return value is the `covered` flag: see PrintNode. The
+// callee, optional `?.` token and type arguments are verbatim, so a
+// multi-line callee taints coverage just as a multi-line argument does.
+func printCallExpression(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   if node == nil {
-    return Doc{}
+    return Doc{}, true
   }
   call := node.AsCallExpression()
   if call == nil {
-    return verbatim(ctx, node)
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
   parts := []Doc{}
+  covered := true
   if call.Expression != nil {
     parts = append(parts, verbatim(ctx, call.Expression))
+    covered = covered && !nodeSpansMultipleLines(ctx, call.Expression)
   }
   // Question-dot for optional call: `foo?.(x)`. The token byte range
   // lives between Expression.End() and the open paren; copy
@@ -43,38 +49,45 @@ func printCallExpression(ctx *PrintContext, node *shimast.Node) Doc {
     parts = append(parts, verbatimRange(ctx.Source, callTypeArgsStart(ctx, call), callTypeArgsEnd(ctx, call)))
   }
   if hasNilEntry(call.Arguments) {
-    return verbatim(ctx, node)
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
-  parts = append(parts, printArgList(ctx, call.Arguments))
-  return Concat(parts...)
+  argDoc, argCovered := printArgList(ctx, call.Arguments)
+  parts = append(parts, argDoc)
+  return Concat(parts...), covered && argCovered
 }
 
 // printNewExpression renders a NewExpression. It mirrors the call
 // expression printer; the only difference is the leading `new ` keyword
 // and the optional argument list (NewExpression may omit args entirely,
 // e.g. `new Foo`).
-func printNewExpression(ctx *PrintContext, node *shimast.Node) Doc {
+//
+// The second return value is the `covered` flag: see PrintNode.
+func printNewExpression(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
   if node == nil {
-    return Doc{}
+    return Doc{}, true
   }
   ne := node.AsNewExpression()
   if ne == nil {
-    return verbatim(ctx, node)
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
   }
   parts := []Doc{Text("new ")}
+  covered := true
   if ne.Expression != nil {
     parts = append(parts, verbatim(ctx, ne.Expression))
+    covered = covered && !nodeSpansMultipleLines(ctx, ne.Expression)
   }
   if ne.TypeArguments != nil {
     parts = append(parts, verbatimRange(ctx.Source, newTypeArgsStart(ctx, ne), newTypeArgsEnd(ctx, ne)))
   }
   if ne.Arguments != nil {
     if hasNilEntry(ne.Arguments) {
-      return verbatim(ctx, node)
+      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
     }
-    parts = append(parts, printArgList(ctx, ne.Arguments))
+    argDoc, argCovered := printArgList(ctx, ne.Arguments)
+    parts = append(parts, argDoc)
+    covered = covered && argCovered
   }
-  return Concat(parts...)
+  return Concat(parts...), covered
 }
 
 // hasNilEntry reports whether any entry of `list` is a nil pointer.
@@ -94,29 +107,128 @@ func hasNilEntry(list *shimast.NodeList) bool {
 }
 
 // printArgList renders an argument node list. The shared printList
-// handles the open-comma-close shape; this helper just gathers the
-// per-argument docs.
-func printArgList(ctx *PrintContext, list *shimast.NodeList) Doc {
+// handles the open-comma-close shape; this helper gathers the
+// per-argument docs and threads each argument's `covered` flag up.
+//
+// When the final argument is a block-bodied callback or object literal,
+// the list renders in the "last-argument hugging" shape (see
+// printListHuggingLast): the callback's own body carries the multi-line
+// layout, so the parens stay attached and the preceding arguments are
+// not exploded onto their own lines. This is the Prettier behavior for
+// `foo(x, () => { … })`.
+func printArgList(ctx *PrintContext, list *shimast.NodeList) (Doc, bool) {
   if list == nil {
-    return Text("()")
+    return Text("()"), true
   }
   items := make([]Doc, 0, len(list.Nodes))
+  covered := true
   for _, arg := range list.Nodes {
-    doc, _ := PrintNode(ctx, arg)
+    doc, childCovered := PrintNode(ctx, arg)
+    covered = covered && childCovered
     items = append(items, doc)
   }
-  return printList(ctx, listShape{
+  // AddComma honors `format.trailingComma`: call / new argument lists
+  // accepted trailing commas only in ES2017+, so Prettier's "es5" and
+  // "none" modes skip them here. Hardcoding `true` would oscillate
+  // against Prettier on every cascade pass on any project configured
+  // with "es5" (rxjs hit this on ajax.ts and several operators / testing
+  // helpers — the rule said "no comma needed" while the printer added
+  // one back on its own reflow).
+  shape := listShape{
     OpenTok:  "(",
     CloseTok: ")",
     Items:    items,
     Space:    false,
-    AddComma: true,
-  })
+    AddComma: ctx.allowsCallArgumentTrailingComma(),
+    HugLast:  shouldHugLastArgument(list.Nodes),
+  }
+  return printList(ctx, shape), covered
+}
+
+// shouldHugLastArgument reports whether the final entry of `args` is a
+// shape Prettier keeps hugging the closing paren: an object or array
+// literal, a function expression, or an arrow function whose body is a
+// block, an object literal, or an array literal. Hugging only applies
+// when that argument is genuinely the last one; a callback in the
+// middle of the list does not trigger the shape.
+//
+// An arrow with any other expression body (`(x) => x.id`) is
+// deliberately excluded. Such a body carries no internal break point,
+// so the hugging shape — a flat `Concat` with no Group — would pin the
+// whole call to one line even when that line overflows printWidth.
+// Routing it through the normal list shape instead lets the argument
+// list explode onto its own line when the call does not fit, which is
+// what Prettier does.
+func shouldHugLastArgument(args []*shimast.Node) bool {
+  if len(args) == 0 {
+    return false
+  }
+  last := args[len(args)-1]
+  if last == nil {
+    return false
+  }
+  switch last.Kind {
+  case shimast.KindFunctionExpression,
+    shimast.KindObjectLiteralExpression,
+    shimast.KindArrayLiteralExpression:
+    return true
+  case shimast.KindArrowFunction:
+    arrow := last.AsArrowFunction()
+    if arrow == nil || arrow.Body == nil {
+      return false
+    }
+    body := arrow.Body
+    // `(x) => ({ … })` parenthesizes its object body; hug on the inner
+    // expression, mirroring Prettier's couldExpandArg.
+    if body.Kind == shimast.KindParenthesizedExpression {
+      if p := body.AsParenthesizedExpression(); p != nil && p.Expression != nil {
+        body = p.Expression
+      }
+    }
+    switch body.Kind {
+    case shimast.KindBlock,
+      shimast.KindObjectLiteralExpression,
+      shimast.KindArrayLiteralExpression:
+      return true
+    }
+  }
+  return false
+}
+
+// forceBreakFirstGroup returns `doc` with the first Group found in a
+// left-to-right walk of its subtree forced broken, and reports whether
+// one was found. printListHuggingLast uses it to commit a hugged
+// argument — an object or array literal, possibly nested inside an
+// arrow body (`(x) => ({ … })`) — to its multi-line shape. The caller
+// guards the walk with flatten: it is only run on an item that has no
+// hard line breaks of its own, so the first Group reached is the
+// hugged literal itself, never an unrelated Group inside a block body.
+func forceBreakFirstGroup(doc Doc) (Doc, bool) {
+  switch doc.Kind {
+  case docGroup:
+    doc.Break = true
+    return doc, true
+  case docConcat, docIndent, docAlign:
+    children := make([]Doc, len(doc.Children))
+    copy(children, doc.Children)
+    for i, child := range children {
+      broken, done := forceBreakFirstGroup(child)
+      if done {
+        children[i] = broken
+        doc.Children = children
+        return doc, true
+      }
+    }
+  }
+  return doc, false
 }
 
 // Type-argument byte-range helpers. The shim's NodeList.End() points
 // past the last argument; the surrounding `<` and `>` are not part of
 // the list's range, so we have to scan around it.
+
+// callTypeArgsStart returns the byte offset of the `<` that opens the
+// type-argument list of a CallExpression. Returns -1 when absent.
 func callTypeArgsStart(ctx *PrintContext, call *shimast.CallExpression) int {
   if call.TypeArguments == nil || len(call.TypeArguments.Nodes) == 0 {
     return -1
@@ -136,6 +248,8 @@ func callTypeArgsStart(ctx *PrintContext, call *shimast.CallExpression) int {
   return -1
 }
 
+// callTypeArgsEnd returns the byte offset one past the closing `>` of a
+// CallExpression's type-argument list. Returns -1 when absent.
 func callTypeArgsEnd(ctx *PrintContext, call *shimast.CallExpression) int {
   if call.TypeArguments == nil {
     return -1
@@ -149,6 +263,8 @@ func callTypeArgsEnd(ctx *PrintContext, call *shimast.CallExpression) int {
   return end
 }
 
+// newTypeArgsStart returns the byte offset of the `<` that opens the
+// type-argument list of a NewExpression. Returns -1 when absent.
 func newTypeArgsStart(ctx *PrintContext, ne *shimast.NewExpression) int {
   if ne.TypeArguments == nil || len(ne.TypeArguments.Nodes) == 0 {
     return -1
@@ -166,6 +282,8 @@ func newTypeArgsStart(ctx *PrintContext, ne *shimast.NewExpression) int {
   return -1
 }
 
+// newTypeArgsEnd returns the byte offset one past the closing `>` of a
+// NewExpression's type-argument list. Returns -1 when absent.
 func newTypeArgsEnd(ctx *PrintContext, ne *shimast.NewExpression) int {
   if ne.TypeArguments == nil {
     return -1

package/linthost/print_nodes_function.go

@@ -0,0 +1,353 @@
+package linthost
+
+import (
+  "strings"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+)
+
+// Function-shaped and statement-body node printers: arrow functions,
+// function expressions, parenthesized expressions, block statements,
+// and the two leaf statements a callback body is almost always made of
+// — expression statements and return statements.
+//
+// These printers exist for one job: make callback-bearing code
+// (`new Singleton(() => { … })`, `foo(x, function () { … })`) reflow
+// with *consistent* indentation. The headline bug they fix is the
+// verbatim-column hazard — an un-handled multi-line node keeps the
+// source columns its lines were written at, so when the enclosing call
+// re-indents, the callback header and its body drift apart.
+//
+// Coverage discipline. The signature (parameters, `=>` / `function`
+// keyword, return type) is emitted verbatim because it almost never
+// contains a newline and is not a reflow target. The *body* is where
+// the newlines live, so the body is dispatched through PrintNode and
+// re-indented by the Doc engine. Each printer ANDs the body's `covered`
+// flag into its own result: a body the dispatcher cannot fully control
+// taints the whole subtree and the format/print-width rule abstains.
+//
+// The expression- and return-statement printers carry the same
+// discipline one level deeper: a callback body whose statements are
+// themselves calls (`outer(() => { inner(() => { … }); })`) only
+// reflows when those statements dispatch to a real printer. Without
+// them every multi-line statement would be verbatim and a nested
+// callback would always abstain.
+
+// printArrowFunction renders an arrow function. The portion before the
+// body — parameters, optional return type, `=>` token — is emitted
+// verbatim; only the body participates in reflow.
+//
+//  verbatim prefix      reflowed body
+//  ┌──────────────┐     ┌──────────┐
+//  (a, b): number =>    { return a; }
+//
+// A concise (expression) body is dispatched directly. A block body
+// flows through printBlock, which re-indents its statements relative
+// to the printer's current indent.
+//
+// The second return value is the `covered` flag: see PrintNode. The
+// verbatim prefix is single-line in every realistic arrow, but a
+// pathological multi-line parameter list would still taint coverage.
+func printArrowFunction(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
+  if node == nil {
+    return Doc{}, true
+  }
+  arrow := node.AsArrowFunction()
+  if arrow == nil || arrow.Body == nil {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  return printFunctionLike(ctx, node, arrow.Body)
+}
+
+// printFunctionExpression renders a `function` expression. Like the
+// arrow printer, the signature is verbatim and only the body reflows.
+// Function expressions always carry a block body, so the body always
+// flows through printBlock.
+//
+// The second return value is the `covered` flag: see PrintNode.
+func printFunctionExpression(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
+  if node == nil {
+    return Doc{}, true
+  }
+  fn := node.AsFunctionExpression()
+  if fn == nil || fn.Body == nil {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  return printFunctionLike(ctx, node, fn.Body)
+}
+
+// printFunctionLike is the shared body of the arrow / function-expression
+// printers. It slices the verbatim signature from the node's first byte
+// up to the body's first byte, dispatches the body, and concatenates
+// the two.
+//
+// The signature slice intentionally includes the whitespace between the
+// signature and the body (`=> ` keeps its trailing space, `) ` before a
+// `function` body keeps its space) so the flat form reads naturally and
+// the body's open brace lands where the user put it.
+func printFunctionLike(ctx *PrintContext, node, body *shimast.Node) (Doc, bool) {
+  nodeStart := shimscanner.SkipTrivia(ctx.Source, node.Pos())
+  bodyStart := shimscanner.SkipTrivia(ctx.Source, body.Pos())
+  if nodeStart < 0 || bodyStart < nodeStart || bodyStart > len(ctx.Source) {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  prefix := verbatimRange(ctx.Source, nodeStart, bodyStart)
+  // A signature that itself spans multiple lines is a verbatim slice
+  // with frozen interior columns — taint coverage so the rule abstains.
+  prefixCovered := !strings.Contains(ctx.Source[nodeStart:bodyStart], "\n")
+  bodyDoc, bodyCovered := PrintNode(ctx, body)
+  return Concat(prefix, bodyDoc), prefixCovered && bodyCovered
+}
+
+// printParenthesizedExpression renders `( expr )`. The parentheses are
+// fixed punctuation; the inner expression is dispatched so a call or
+// object literal wrapped in parens still reflows.
+//
+// The second return value is the `covered` flag: see PrintNode.
+func printParenthesizedExpression(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
+  if node == nil {
+    return Doc{}, true
+  }
+  paren := node.AsParenthesizedExpression()
+  if paren == nil || paren.Expression == nil {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  inner, covered := PrintNode(ctx, paren.Expression)
+  return Concat(Text("("), inner, Text(")")), covered
+}
+
+// printBlock renders a `{ … }` block statement. A statement-free block
+// collapses to `{}`. A non-empty block always renders multi-line —
+// matching every JavaScript formatter — with each statement on its own
+// line, indented one unit from the block's base indent and the closing
+// brace back at the base indent.
+//
+//  {
+//    stmt;
+//    stmt;
+//  }
+//
+// Each statement is dispatched through PrintNode, so a statement that
+// is itself reflowable (a long call) gets reflowed and a plain
+// statement falls back to verbatim. Because the engine re-applies the
+// indent at every Hardline, even a verbatim statement lands at the
+// correct column — the verbatim-column hazard only bites *multi-line*
+// verbatim nodes, and those taint `covered` so the rule abstains.
+//
+// The second return value is the `covered` flag: see PrintNode. A block
+// is uncovered when any statement is uncovered, or when the block
+// carries a comment that lives outside every statement's byte range —
+// the freshly minted Hardline separators have no carrier slot for such
+// trivia, so reflowing would silently drop the comment. The
+// comment check guards the statement-free path too: `{ /* note */ }`
+// has no statements but is *not* an empty block — collapsing it to `{}`
+// would delete the comment, so the printer emits it verbatim instead.
+func printBlock(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
+  if node == nil {
+    return Doc{}, true
+  }
+  block := node.AsBlock()
+  if block == nil || block.Statements == nil {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  hasComment := blockHasNonStatementComment(ctx, node, block.Statements.Nodes)
+  if len(block.Statements.Nodes) == 0 {
+    if hasComment {
+      // `{ /* … */ }` — not collapsible without dropping the comment.
+      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+    }
+    return Text("{}"), true
+  }
+  stmts := block.Statements.Nodes
+  items := make([]Doc, 0, len(stmts))
+  covered := !hasComment
+  for _, stmt := range stmts {
+    if stmt == nil {
+      return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+    }
+    doc, childCovered := PrintNode(ctx, stmt)
+    covered = covered && childCovered
+    items = append(items, doc)
+  }
+  // Join statements with a Hardline, preserving a single user-authored
+  // blank line between consecutive statements. The block printer mints
+  // fresh separators, so a bare `Join(Hardline, …)` would silently
+  // delete every blank line in the body on the first reflow. The blank
+  // line is a Literalline — a bare newline with no indent — so the
+  // empty line carries no trailing whitespace. Two or more blank lines
+  // collapse to one, matching Prettier.
+  bodyParts := make([]Doc, 0, len(items)*2)
+  for i, item := range items {
+    if i > 0 {
+      if blankLineBetweenStatements(ctx.Source, stmts[i-1].End(), stmts[i].Pos()) {
+        bodyParts = append(bodyParts, Literalline())
+      }
+      bodyParts = append(bodyParts, Hardline())
+    }
+    bodyParts = append(bodyParts, item)
+  }
+  doc := Concat(
+    Text("{"),
+    Indent(ctx.indentUnit(), Hardline(), Concat(bodyParts...)),
+    Hardline(),
+    Text("}"),
+  )
+  return doc, covered
+}
+
+// blankLineBetweenStatements reports whether the source gap between the
+// end of one block statement and the start of the next contains a blank
+// line — two or more newlines. printBlock uses it to keep a single
+// user-authored blank line between statements. blockHasNonStatementComment
+// has already guaranteed the gap holds no comment when the block is
+// covered, so the gap is pure whitespace and counting newlines suffices.
+func blankLineBetweenStatements(src string, prevEnd, nextPos int) bool {
+  nextStart := shimscanner.SkipTrivia(src, nextPos)
+  if prevEnd < 0 || nextStart > len(src) || nextStart <= prevEnd {
+    return false
+  }
+  newlines := 0
+  for i := prevEnd; i < nextStart; i++ {
+    if src[i] == '\n' {
+      newlines++
+      if newlines >= 2 {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+// blockHasNonStatementComment reports whether the block's byte range
+// holds a `//` or `/*` outside every statement's token range. The block
+// printer joins statements with bare Hardlines that have no slot for
+// inter-statement trivia, so a stray comment would be dropped by a
+// reflow. Detecting it lets printBlock report the block uncovered and
+// the format/print-width rule abstain.
+//
+// The scan mirrors rules_format_print_width.go::hasNonChildComments:
+// comment-shaped bytes inside a complete statement token range (string
+// literals, nested comments) are masked, so only genuine
+// inter-statement comments surface.
+func blockHasNonStatementComment(ctx *PrintContext, node *shimast.Node, stmts []*shimast.Node) bool {
+  start := shimscanner.SkipTrivia(ctx.Source, node.Pos())
+  end := node.End()
+  if start < 0 || end < start || end > len(ctx.Source) {
+    return false
+  }
+  type span struct{ pos, end int }
+  ranges := make([]span, 0, len(stmts))
+  for _, stmt := range stmts {
+    if stmt == nil {
+      continue
+    }
+    ranges = append(ranges, span{shimscanner.SkipTrivia(ctx.Source, stmt.Pos()), stmt.End()})
+  }
+  inStatement := func(i int) bool {
+    for _, r := range ranges {
+      if i >= r.pos && i < r.end {
+        return true
+      }
+    }
+    return false
+  }
+  src := ctx.Source
+  for i := start; i < end-1 && i < len(src)-1; i++ {
+    if inStatement(i) {
+      continue
+    }
+    if src[i] == '/' && (src[i+1] == '/' || src[i+1] == '*') {
+      return true
+    }
+  }
+  return false
+}
+
+// printExpressionStatement renders an `expr;` statement. The expression
+// is dispatched so a callback-body statement that is itself a call or
+// object literal reflows; the trailing `;` is preserved when the source
+// carries one.
+//
+// The dispatcher reaches this printer through the block printer, so
+// nested callbacks (`outer(() => { inner(() => { … }); })`) reflow at
+// every depth instead of stalling on the verbatim fallback.
+//
+// The second return value is the `covered` flag: see PrintNode. The
+// printer falls back to verbatim when the gap between the expression
+// and the statement end holds anything other than the optional `;` and
+// whitespace — a comment in that gap has no carrier slot and would be
+// dropped.
+func printExpressionStatement(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
+  if node == nil {
+    return Doc{}, true
+  }
+  stmt := node.AsExpressionStatement()
+  if stmt == nil || stmt.Expression == nil {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  if !tailIsCleanTerminator(ctx.Source, stmt.Expression.End(), node.End()) {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  exprDoc, covered := PrintNode(ctx, stmt.Expression)
+  parts := []Doc{exprDoc}
+  if sourceHasStatementTerminator(ctx.Source, node.End()) {
+    parts = append(parts, Text(";"))
+  }
+  return Concat(parts...), covered
+}
+
+// printReturnStatement renders a `return expr;` statement. Like the
+// expression-statement printer, the returned expression is dispatched
+// so a returned callback or object literal reflows.
+//
+// A bare `return;` carries no expression and is emitted verbatim — it
+// is a single token with nothing to reflow.
+//
+// The second return value is the `covered` flag: see PrintNode. The
+// printer falls back to verbatim when the gap between the expression
+// and the statement end holds anything but the optional `;` and
+// whitespace.
+func printReturnStatement(ctx *PrintContext, node *shimast.Node) (Doc, bool) {
+  if node == nil {
+    return Doc{}, true
+  }
+  stmt := node.AsReturnStatement()
+  if stmt == nil || stmt.Expression == nil {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  if !tailIsCleanTerminator(ctx.Source, stmt.Expression.End(), node.End()) {
+    return verbatim(ctx, node), !nodeSpansMultipleLines(ctx, node)
+  }
+  exprDoc, covered := PrintNode(ctx, stmt.Expression)
+  parts := []Doc{Text("return "), exprDoc}
+  if sourceHasStatementTerminator(ctx.Source, node.End()) {
+    parts = append(parts, Text(";"))
+  }
+  return Concat(parts...), covered
+}
+
+// tailIsCleanTerminator reports whether src[exprEnd:stmtEnd] holds only
+// whitespace and at most one `;`. The expression- and return-statement
+// printers consult it before re-minting the trailing `;`: a comment or
+// any other token in that gap would be dropped by the reflow, so the
+// printer must fall back to verbatim instead.
+func tailIsCleanTerminator(src string, exprEnd, stmtEnd int) bool {
+  if exprEnd < 0 || stmtEnd < exprEnd || stmtEnd > len(src) {
+    return false
+  }
+  semis := 0
+  for i := exprEnd; i < stmtEnd; i++ {
+    switch src[i] {
+    case ' ', '\t', '\r', '\n':
+    case ';':
+      semis++
+      if semis > 1 {
+        return false
+      }
+    default:
+      return false
+    }
+  }
+  return true
+}