Renaming and Datatype rules

[cdietrich]

in our grammars we make heavy use of datatype rules for names and cross refs (name=SomeRule, ref=[SomeType:SomeRule])
the current implementation in the langium tooling around renaming
findDeclarationNodeAtOffset / findDeclaration / isNameNode etc heavily relys on terminals / pure leaf nodes being used for names / references.

what is your recommendation for that? mingle with the cst tree manually inside renameprovider rename/prepare rename?
i miss some utils for this e.g.
give me the complete node for this cross reference this leaf node is part of

[msujew]

Hey @cdietrich,

we have written a few custom refactoring services for that in the past. See also the one for the domainmodel example language:

langium/examples/domainmodel/src/language-server/domain-model-rename-refactoring.ts

Lines 27 to 69 in de4607c

	override async rename(document: LangiumDocument, params: RenameParams): Promise<WorkspaceEdit | undefined> {
	const changes: Record<string, TextEdit[]> = {};
	const rootNode = document.parseResult.value.$cstNode;
	if (!rootNode) return undefined;
	const offset = document.textDocument.offsetAt(params.position);
	const leafNode = CstUtils.findDeclarationNodeAtOffset(rootNode, offset, this.grammarConfig.nameRegexp);
	if (!leafNode) return undefined;
	const targetNode = this.references.findDeclaration(leafNode);
	if (!targetNode) return undefined;
	if (isNamed(targetNode)) targetNode.name = params.newName;
	const location = this.getNodeLocation(targetNode);
	if (location) {
	const change = TextEdit.replace(location.range, params.newName);
	const uri = location.uri;
	if (uri) {
	if (changes[uri]) {
	changes[uri].push(change);
	} else {
	changes[uri] = [change];
	}
	}
	}
	for (const node of AstUtils.streamAst(targetNode)) {
	const qn = this.buildQualifiedName(node);
	if (qn) {
	const options = { onlyLocal: false, includeDeclaration: false };
	this.references.findReferences(node, options).forEach(reference => {
	const nodeLocation = this.getRefLocation(reference);
	const isQn = this.hasQualifiedNameText(reference.sourceUri, reference.segment.range);
	let newName = qn;
	if (!isQn) newName = params.newName;
	const nodeChange = TextEdit.replace(nodeLocation.range, newName);
	if (changes[nodeLocation.uri]) {
	changes[nodeLocation.uri].push(nodeChange);
	} else {
	changes[nodeLocation.uri] = [nodeChange];
	}
	});
	}
	}
	return { changes };
	}

[cdietrich]

@msujew i already saw that. my problem is this code i need

 protected override renameNodeRange(doc: LangiumDocument, position: Position): Range | undefined {
    const rootNode = doc.parseResult.value.$cstNode
    const offset = doc.textDocument.offsetAt(position)
    if (rootNode && offset) {
      const leafNode = CstUtils.findDeclarationNodeAtOffset(rootNode, offset, this.grammarConfig.nameRegexp)
      if (!leafNode) {
        return undefined
      }
      const isCrossRef = this.references.findDeclaration(leafNode) // TODO do we want this?
      // return range if selected CstNode is the name node or it is a crosslink which points to a declaration
      if (isCrossRef) {
        const viech = GrammarUtils.findAssignment(leafNode)
        if (viech !== undefined && GrammarAST.isCrossReference(viech?.terminal)) {
          const cr = viech?.terminal
          // TODO safe
          if ("QualifiedPATH" === (cr?.terminal as GrammarAST.RuleCall)?.rule?.ref?.name) {
            // TODO
            let tempLeaf: CstNode | undefined = leafNode
            while (tempLeaf && tempLeaf.grammarSource !== cr) {
              tempLeaf = tempLeaf.container
            }
            if (tempLeaf !== undefined) {
              if (isFqn(tempLeaf?.text)) {
                const index = tempLeaf.text.lastIndexOf(Fqn.separator)
                const o = AstUtils.getDocument(tempLeaf.astNode).textDocument.offsetAt(tempLeaf.range.start)
                const p1 = AstUtils.getDocument(tempLeaf.astNode).textDocument.positionAt(
                  o + index + Fqn.separator.length
                )
                const sigRange = {
                  start: p1,
                  end: tempLeaf.range.end,
                }
                return sigRange
              }
              return tempLeaf.range
            }
          }
          console.log(viech?.terminal?.terminal)
        } else if (viech !== undefined && GrammarAST.isRuleCall(viech?.terminal)) {
          const rc = viech?.terminal
          if ("PATH" === rc?.rule?.ref?.name) {
            let tempLeaf: CstNode | undefined = leafNode
            while (tempLeaf && tempLeaf.grammarSource !== rc) {
              tempLeaf = tempLeaf.container
            }
            if (tempLeaf !== undefined) {
              return tempLeaf.range // everything
            }
          }
          console.log(viech?.terminal)
        }

        //const xxx = this.references.findDeclarationNode(leafNode)
        //console.log(xxx)
        return leafNode.range // TODO handle path situation
      }
      if (this.isNameNode(leafNode) === true) {
        //const nn = this.nameProvider.getNameNode(leafNode.astNode)
        //console.log(nn?.text)
        return leafNode.range // TODO handle path situation
      }
    }
    return undefined
  }

is there a easier way to get the complete crossref/name-assignment nodes using some utils i dont know

[msujew]

I think you should be able to traverse the CST up until you reach the Assignment grammarSource element and use the text value of that node.

[cdietrich]

So basically what I am doing

[cdietrich]

Maybe with the logic inverted. So first figure out the parent cross ref or assignment and then care about the rest (decl vs ref )