Formatting Datatype rules

[cdietrich]

Hi, is there a way to format datatype rules with langium?

besides sth like this

space = /\s+/g

  private isCstNodeDatatypeRule(cst: CstNode): boolean {
    const dataTypeRuleNames = ["QualifiedPATH", "PATH", "EndpointPath"]

    const getDatatypeRule: (a: GrammarAST.AbstractElement | undefined) => GrammarAST.ParserRule | undefined = a => {
      if (GrammarAST.isRuleCall(a) && GrammarAST.isParserRule(a.rule.ref) && GrammarUtils.isDataTypeRule(a.rule.ref)) {
        return a.rule.ref
      }
      return undefined
    }

    if (GrammarAST.isCrossReference(cst.grammarSource)) {
      const terminal = cst.grammarSource.terminal
      const dataTypeRule = getDatatypeRule(terminal)
      return dataTypeRule !== undefined && dataTypeRuleNames.includes(dataTypeRule?.name)
    } else if (GrammarAST.isRuleCall(cst.grammarSource)) {
      const dataTypeRule = getDatatypeRule(cst.grammarSource)
      return dataTypeRule !== undefined && dataTypeRuleNames.includes(dataTypeRule?.name)
    }

    return false
  }

  protected override iterateCstFormatting(
    document: LangiumDocument,
    formattings: Map<string, FormattingAction>,
    options: LspFormattingOptions,
    range?: Range
  ): TextEdit[] {
    const result = super.iterateCstFormatting(document, formattings, options, range)
    if (document.parseResult.value.$cstNode !== undefined) {
      const treeIterator = CstUtils.streamCst(document.parseResult.value.$cstNode).iterator()
      for (const cst of treeIterator) {
        if (this.isCstNodeDatatypeRule(cst)) {
          if (this.insideRange(cst.range, range)) {
            const textWithoutSpaces = cst.text.replaceAll(this.space, "")
            if (textWithoutSpaces !== cst.text) {
              const newEdit = TextEdit.replace(cst.range, textWithoutSpaces)
              result.push(newEdit)
            }
          }
          treeIterator.prune()
        }
      }
    }
    return result.sort((a, b) => {
      // Sort by start line first
      if (a.range.start.line !== b.range.start.line) {
        return a.range.start.line - b.range.start.line
      }
      // If on same line, sort by start character
      return a.range.start.character - b.range.start.character
    })
  }
}

[msujew]

Hey @cdietrich,

sorry for not getting back to this earlier - I had some time to think about this now. I'm wondering whether the following approach works:

The node formatter also allows to format individual CST nodes via the cst function. Meaning that if you somehow gather the CST nodes that make up the content of a data type rule, you can format them. I.e. in this grammar:

Value: name=FQN;
FQN: ID ("." ID)*;

You can first grab the cst node for the name property and then iterate over the subnodes to format them via the cst function. Does that make sense? I didn't try it, but it should probably work.

[cdietrich]

thx for the hint. will give this a shot on monday.
this at least sounds clear than my solution and would also spare the sorting