21772072879

Committed 07 Feb 2026 01:50AM UTC coverage: 91.42% (-0.2%) from 91.596%

Build # 21772072879

Build Type

Pull #1779

github

Committed by

web-flow

Commit Message

Merge 817af4c6a into 3f8c07ee4

Pull Request Pull Request #1779: LSP: fix(diagnostics), ensure immediate updates for opened dependent files on change

Run Details

3777 of 4118 branches covered (91.72%)

Branch coverage included in aggregate %.

19185 of 20999 relevant lines covered (91.36%)

17409.21 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.15

/source/parser/declaration.civet

import type {
  AccessStart
  ASTLeaf
  ASTNode
  ASTNodeParent
  ASTRef
  AwaitExpression
  Binding
  BlockStatement
  Declaration
  ExpressionNode
  IfStatement
  Initializer
  IterationStatement
  ParenthesizedExpression
  StatementTuple
  SwitchStatement
  TypeSuffix
  WithClause
  Whitespace
  WSNode
} from ./types.civet

import {
  blockContainingStatement
  blockWithPrefix
  braceBlock
  insertBlockStatements
  makeEmptyBlock
  replaceBlockExpression
} from ./block.civet

import {
  findAncestor
  findChildIndex
  gatherRecursiveAll
} from ./traversal.civet

import {
  getPatternBlockPrefix
  getPatternConditions
} from ./pattern-matching.civet

import {
  append
  convertOptionalType
  insertTrimmingSpace
  isExit
  isWhitespaceOrEmpty
  literalType
  makeLeftHandSideExpression
  makeNode
  parenthesizeExpression
  replaceNode
  spliceChild
  typeOfExpression
  trimFirstSpace
  updateParentPointers
} from ./util.civet

import {
  makeRef
  maybeRef
} from ./ref.civet

import {
  assignResults
  wrapIterationReturningResults
} from ./function.civet

import {
  gatherBindingCode
  gatherSubbindings
  simplifyBindingProperties
} from ./binding.civet

import {
  convertNamedImportsToObject
  processCallMemberExpression
} from ./lib.civet

function processAssignmentDeclaration(decl: ASTLeaf, pattern: Binding["pattern"], typeSuffix: TypeSuffix?, ws: WSNode, assign: ASTLeaf, e: ASTNode)
  // Adjust position to space before assignment to make TypeScript remapping happier
  decl = {
    ...decl,
    $loc:
      pos: assign.$loc.pos - 1
      length: assign.$loc.length + 1
  }

  [splices, assignments] .= gatherBindingCode pattern

  splices = splices.map (s) => [", ", s]
  thisAssignments := assignments.map (a) => ["", a, ";"] as const

  typeSuffix ??= pattern.typeSuffix if "typeSuffix" in pattern
  initializer := makeNode
    type: "Initializer"
    expression: e
    children: [ws, assign, e]
  binding := makeNode {
    type: "Binding"
    pattern
    initializer
    splices
    typeSuffix
    thisAssignments
    children: [pattern, typeSuffix, initializer]
  }

  children := [decl, binding]

  makeNode {
    type: "Declaration"
    pattern.names
    decl
    bindings: [binding]
    splices
    thisAssignments
    children
  }

function processDeclarations(statements: StatementTuple[]): void
  for each declaration of gatherRecursiveAll statements, .type is "Declaration"
    { bindings } := declaration
    continue unless bindings?

    for i of [bindings#>..0]
      binding := bindings[i]
      subbindings := gatherSubbindings binding
      if subbindings#
        simplifyBindingProperties binding
        simplifyBindingProperties subbindings
        // Add subbindings after this binding
        spliceChild declaration, binding, 1, binding, subbindings

    for each binding of bindings
      { typeSuffix, initializer } .= binding

      if typeSuffix and typeSuffix.optional
        // Convert `let x? = y` to `let x: undefined | typeof y = y`
        if initializer and not typeSuffix.t
          expression := trimFirstSpace initializer.expression!
          typeSuffix.t = typeOfExpression expression
          unless typeSuffix.t?
            spliceChild binding, typeSuffix, 1,
              type: "Error"
              message:
                if expression is like {type: "Literal", subtype: "NullLiteral"}
                  "Optional type can't be inferred from null"
                else if expression is like {type: "Identifier", name: "undefined"}
                  "Optional type can't be inferred from undefined"
                else
                  `Optional type can only be inferred from literals or member expressions, not ${expression.type}`
            continue
          typeSuffix.children.push ": ", typeSuffix.t
        if typeSuffix.t
          // Convert `let x?: T` to `let x: undefined | T`
          convertOptionalType typeSuffix
        else
          // Convert `let x?` to `let x = undefined`
          spliceChild binding, typeSuffix, 1
          binding.children.push initializer = binding.initializer =
            type: "Initializer"
            expression: "undefined"
            children: [" = ", "undefined"]

      // If this declaration is at the top level (not e.g. inside an
      // ExportDeclaration), try to pull out any statement expressions
      if initializer and blockContainingStatement declaration
        prependStatementExpressionBlock initializer, declaration

  for each statement of gatherRecursiveAll statements, .type is "ForStatement"
    { declaration } := statement
    continue unless declaration?.type is "ForDeclaration"
    { binding } := declaration
    blockPrefix := getPatternBlockPrefix
      binding.pattern
      undefined
      append declaration.decl, " "
      binding.typeSuffix
    simplifyBindingProperties binding
    if blockPrefix?
      statement.block.expressions.unshift ...blockPrefix
      braceBlock statement.block

function prependStatementExpressionBlock(initializer: Initializer, statement: ASTNodeParent): ASTRef?
  {expression: exp} .= initializer

  // Handle nested statement expression
  let ws: Whitespace
  if Array.isArray(exp) and exp# is 2 and isWhitespaceOrEmpty exp[0]
    ws = exp[0]
    exp = exp[1]!

  return unless exp is like {type: "StatementExpression"}, {type: "SpreadElement", expression: {type: "StatementExpression"}}

  statementExp := exp.statement
  blockStatement: StatementTuple := [ws || "", statementExp, ";"]
  pre: StatementTuple[] := [blockStatement]
  let ref: ASTRef

  if statementExp.type is "IterationExpression"
    // Async and generator iterations remain inline wrapped with IIFE
    return if statementExp.async or statementExp.generator

    statement := statementExp.statement
    blockStatement[1] = statement

    // Leave comptime statements wrapped in IIFE
    return if statement.type is "ComptimeStatement"

    if statement.type is "DoStatement"
      ref = initializer.expression = initializer.children[2] = makeRef()
      assignResults blockStatement, (resultNode) =>
        //@ts-ignore
        makeNode
          type: "AssignmentExpression"
          children: [ref, " = ", resultNode]

      refDec :=
        type: "Declaration"
        children: ["let ", ref]

      // @ts-ignore
      pre.unshift ["", refDec, ";"]
    else
      wrapIterationReturningResults statement, => undefined
      ref = initializer.expression = initializer.children[2] = statement.resultsRef
  else
    ref = initializer.expression = initializer.children[2] = makeRef()

    assignResults blockStatement, (resultNode) =>
      //@ts-ignore
      makeNode
        type: "AssignmentExpression"
        children: [ref, " = ", resultNode]

    refDec :=
      type: "Declaration"
      children: ["let ", ref]

    pre.unshift ["", refDec, ";"]

  // Insert the statement from the statement expression
  // (and any helper declarations) into the containing block
  // just before declaration/assignment.
  unless { block, index } := blockContainingStatement statement
    throw new Error "Couldn't find block in prependStatementExpressionBlock"
  insertBlockStatements block, index, ...pre

  return ref

function processDeclarationCondition(condition, rootCondition, parent: ASTNodeParent): void
  return unless condition.type is "DeclarationCondition"

  { decl, bindings } := condition.declaration as Declaration
  // TODO: Add support for `let` and `const` declarations with multiple bindings in conditions
  binding := bindings[0]
  { pattern, typeSuffix, initializer } .= binding
  nullCheck := typeSuffix?.optional and not typeSuffix.t and not typeSuffix.nonnull

  unless initializer?
    condition.children = [
      type: "Error"
      message: "Missing initializer in declaration condition"
    ]
    return

  ref: ASTNode .= prependStatementExpressionBlock(initializer!, parent)

  if ref
    Object.assign condition, {
      type: "AssignmentExpression"
      children: [ref]
      pattern
      ref
      statementDeclaration: true
    }
  else
    { expression } := initializer
    ref = maybeRef expression
    simple := ref is expression
    let children
    if simple
      ref = trimFirstSpace ref
      children = [ref]
    else
      children = [ref, initializer]
      // Wrap declaration that is a plain assignment (no pattern-matching) and the immediate grandchild of an `if` or `while`
      // to satisfy eslint's no-cond-assign rule
      // More complex conditions (triggered by pattern matching or `until`/`unless`) don't need double parens
      grandparent := condition.parent?.parent
      if pattern.type is "Identifier" and (grandparent?.type is "IfStatement" or grandparent?.type is "IterationStatement") and not nullCheck
        children.unshift "("
        children.push ")"

    // `x? := ...` as a condition means `x := ..., x?`
    if nullCheck
      children.unshift "("
      children.push ") != null"
      typeSuffix = undefined

    Object.assign condition, {
      type: "AssignmentExpression"
      children
      hoistDec: unless simple
        type: "Declaration"
        children: ["let ", ref, typeSuffix]
        names: []
      pattern
      ref
    }

  // condition wasn't previously a child, so now needs parent pointers
  updateParentPointers condition, parent

  rootCondition.blockPrefix = getPatternBlockPrefix(pattern, ref, decl, typeSuffix)

function processDeclarationConditions(node: ASTNode): void
  gatherRecursiveAll node,
    (n): n is IfStatement | IterationStatement | SwitchStatement =>
      n.type is "IfStatement" or n.type is "IterationStatement" or n.type is "SwitchStatement"
  .forEach (s) =>
    processDeclarationConditionStatement s

/**
 * Processes adding additional conditions when declarations are used as a condition in IfStatements, WhileStatements, and SwitchStatements.
 * Also does additional processing for IfStatements that used to be in the parser (inserting semi-colon on bare-block consequent with else).
 */
function processDeclarationConditionStatement(s: IfStatement | IterationStatement | SwitchStatement): void
  { condition } := s
  return unless condition?.expression
  { expression } .= condition

  // Support for negated conditions built by unless/until
  if {type: 'UnaryExpression', children: [['!'], {type: 'ParenthesizedExpression', expression: expression2}]} := expression
    expression = expression2

  processDeclarationCondition expression, condition.expression, s

  { ref, pattern } := expression

  if pattern
    conditions := getPatternConditions(pattern, ref)
    .filter (c) =>
      switch c
        // We already check whether the ref is truthy, so it's non-null
        [^ref, " != null"]
          false
        // Keep top-level object checks to be consistent with pattern matching
        // (e.g. exclude {length} := s from matching a string)
        //["typeof ", ^ref, " === 'object'"]
        else
          true

    if conditions#
      children .= condition.children
      // For negated conditions, put conditions inside the negation
      if s.negated
        unless condition.expression is like {type: 'UnaryExpression', children: [['!'], {type: 'ParenthesizedExpression'}]}
          throw new Error "Unsupported negated condition"
        { children } = condition.expression.children[1] as ParenthesizedExpression
      children.unshift "("
      for each c of conditions
        children.push " && ", c
      children.push ")"

  // Move declaration to after the statement for until loops,
  // and for unless conditions with a guaranteed exit in the then clause.
  { blockPrefix } := condition.expression
  if s.negated and blockPrefix and
     (s.type is "IfStatement" and isExit(s.then) or
      s.type is "IterationStatement")
    { ancestor, child } := findAncestor s,
      (a): a is BlockStatement => a.type is "BlockStatement"
    unless ancestor?
      throw new Error "Couldn't find block for postfix declaration"
    index := findChildIndex ancestor.expressions, child
    if index < 0
      throw new Error "Couldn't find where in block to put postfix declaration"
    ancestor.expressions.splice index + 1, 0, ...blockPrefix
    updateParentPointers ancestor
    braceBlock ancestor
    switch s.type
      when "IfStatement"
        // If there's an else clause, and then clause has an exit,
        // move else clause to after the declaration (so it also has access).
        if elseBlock := s.else?.block
          if elseBlock.bare and not elseBlock.semicolon
            elseBlock.children.push elseBlock.semicolon = ";"
          ancestor.expressions.splice index + 1 + blockPrefix#, 0, ['', elseBlock]
          s.children = s.children.filter (is not s.else)
          s.else = undefined
        // Ensure semicolon after if before added declaration
        block := s.then
        if block.bare and not block.semicolon
          block.children.push block.semicolon = ";"
    return

  switch s.type
    when "IfStatement"
      { else: e } := s

      // Prefix then or else block depending on negation
      if s.negated
        if e?
          block := blockWithPrefix blockPrefix, e.block
          e.children = e.children.map & is e.block ? block : &
          e.block = block
          updateParentPointers e
      else
        block := blockWithPrefix blockPrefix, s.then
        s.children = s.children.map & is s.then ? block : &
        s.then = block
        updateParentPointers s

    when "IterationStatement"
      return unless blockPrefix
      { children, block } := s
      newBlock := blockWithPrefix blockPrefix, block
      s.children = children.map & is block ? newBlock : &
      updateParentPointers s

    when "SwitchStatement"
      { ref, statementDeclaration } := condition.expression as! { ref: ASTRef, statementDeclaration: boolean}
      return unless blockPrefix

      replaceNode s.condition, parenthesizeExpression(ref), s

      unless statementDeclaration
        declStatement: StatementTuple := ["", [{
          type: "Declaration",
          children: ["let ", ...condition.expression.children],
        }], ";"]
        blockPrefix.unshift declStatement

      // Wrap switch in a block to properly scope declarations
      block := blockWithPrefix blockPrefix, makeEmptyBlock()
      updateParentPointers block, s.parent
      replaceBlockExpression s.parent as BlockStatement, s, block
      block.expressions.push ["", s]
      s.parent = block

// Convert FromClause into arguments for dynamic import
function dynamizeFromClause(from)
  from = from[1..]  // remove 'from'
  from = trimFirstSpace from
  if assert := from.-1?.assertion
    from.-1.children |>= .filter (is not assert)
    from.push ", {", assert.keyword, ":", assert.object, "}"
  ["(", ...from, ")"]

function dynamizeImportDeclaration(decl)
  { imports } := decl
  { star, binding, specifiers } .= imports
  justDefault := binding and not specifiers and not star
  pattern := do
    if binding
      if specifiers
        makeRef()
      else
        binding
    else
      convertNamedImportsToObject(imports, true)
  c := "const"
  expression := [
    if justDefault then "("
    {type: "Await", children: ["await"]}
    " "
    decl.children[0] // import
    dynamizeFromClause decl.from
    if justDefault then ").default"
  ]
  initializer: Initializer := {
    type: "Initializer"
    expression
    children: [" ", "= ", expression]
  }
  bindings := [{
    type: "Binding"
    names: pattern.names
    pattern
    initializer
    children: [pattern, initializer]
  }]
  if binding and specifiers
    // import x, {y} --> const ref = await import(...), x = ref.default, {y} = ref
    pattern2 := binding
    exp2 := [
      pattern
      ".default"
    ]
    initializer2: Initializer := {
      type: "Initializer"
      expression
      children: [" ", "= ", exp2]
    }
    bindings.push
      type: "Binding"
      names: binding.names
      pattern: pattern2
      initializer: initializer2
      children: [pattern2, initializer2]
    pattern3 := convertNamedImportsToObject(imports.children.at(-1), true)
    initializer3: Initializer := {
      type: "Initializer"
      expression: pattern
      children: [" ", "= ", pattern]
    }
    bindings.push
      type: "Binding"
      names: specifiers.names
      pattern: pattern3
      initializer: initializer3
      children: [pattern3, initializer3]
  {
    type: "Declaration"
    names: imports.names
    bindings
    decl: c
    children: [
      c, " "
      bindings.flatMap (binding, i) => i > 0 ? [", ", binding] : [binding]
    ]
  }

function dynamizeImportDeclarationExpression($0: [ASTNode, Whitespace, ASTNode, Whitespace, ASTNode])
  [imp, ws1, imports, ws2, from] := $0
  awaitExpression: AwaitExpression :=
    type: "AwaitExpression"
    children: []
      { type: "Await", children: ["await"] }
      " "
      imp
      trimFirstSpace ws2
      dynamizeFromClause from
  dot: AccessStart :=
    type: "AccessStart"
    children: ["."]
    optional: false
  switch imports?.type
    when "Identifier" // default import
      processCallMemberExpression
        type: "CallExpression"
        children: []
          parenthesizeExpression awaitExpression
          {}
            type: "PropertyAccess"
            dot
            name: "default"
            children: [ws1, dot, "default"]
    when "Star"
      parenthesizeExpression awaitExpression
    when "Declaration" // named imports
      object := convertNamedImportsToObject imports
      processCallMemberExpression
        type: "CallExpression"
        children: []
          parenthesizeExpression awaitExpression
          {}
            type: "PropertyGlob"
            dot
            object
            children: [ws1, dot, object]
            reversed: true
    else
      throw new Error "Unsupported dynamic import"

function convertWithClause(withClause: WithClause, extendsClause?: [ASTLeaf, WSNode, ExpressionNode])
  let extendsToken, extendsTarget, ws: WSNode
  if extendsClause
    [ extendsToken, ws, extendsTarget ] = extendsClause
  else
    extendsToken =
      type: "Extends"
      children: [" extends"]
    ws = ""
    extendsTarget = "Object"

  wrapped := withClause.targets.reduce (extendsTarget, [wsNext, withTarget]) =>
    args := [ extendsTarget ]
    exp := {
      type: "CallExpression",
      children: [
        makeLeftHandSideExpression(withTarget),
        {
          type: "Call",
          args,
          children: ["(", trimFirstSpace(ws), args, ")"],
        },
      ],
    } as ExpressionNode

    ws = wsNext

    return exp
  , extendsTarget

  // Ensure at least one space after extends token
  return [ extendsToken, insertTrimmingSpace(ws, " "), wrapped ]

export {
  convertWithClause
  dynamizeImportDeclaration
  dynamizeImportDeclarationExpression
  prependStatementExpressionBlock
  processAssignmentDeclaration
  processDeclarationConditions
  processDeclarations
}

DanielXMoore / Civet / 21772072879

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous