Did you look at this ...

The easiest is to use an adapter. This way you do not have to alter the
model to be able to associate a comments with something in the model.

package psenterprise.xtext;

import org.eclipse.emf.common.notify.impl.AdapterImpl;

public class NewCommentAdapter extends AdapterImpl {

    private final String m_CommentText;
	
    public NewCommentAdapter(String commentText) {
        m_CommentText = commentText;
    }

    @Override
    public boolean isAdapterForType(java.lang.Object type) {
        return type == NewCommentAdapter.class;
    }

    public String getCommentText() {
        return m_CommentText;
    }
}

    EList<Adapter> adapters = myEObject.eAdapters();
    adapters.add(new NewCommentAdapter(comment));

    NewCommentAdapter adapter = (NewCommentAdapter) EcoreUtil.getRegisteredAdapter(myEObject, NewCommentAdapter.class);
    if (adapter != null) {
        String comment = adapter.getCommentText();
    }

Alternatively, if you want to add things to the model you need to switch
from a generated to an external (manually maintained model). You can
start with a copy of the generated one. (Generally, this is what
typically what you want at some point in the life cycle of your language
anyway).

Well, I don't know about better, but perhaps more straight forward;

you
could always do it in two passes - first serialize the model, and then
modify it textually (since you have the nodes at this point you know the
offsets and lengths of everything).

(Hint it is easier to do it "in
reverse" - i.e. iterate over text from last char to first and insert
comments (also in reverse). This is easier as you then do not have to
recompute all the offsets for every inserted comment. Finally, reverse
the resulting string).
Then parse the result again (now the node model knows about the
comments) and then serialize it with formatting turned on. Then it is at
least as pretty as what can be done with the formatter.

 1. Programatically add new element to semantic model.
 2. Serialize the semantic model.
 3. Parse the serialized model created at (2).
    - You didn't say this but I think it's necessary because we need a node model that has the offsets including the "new element".
 4. Somehow identify the "new element" in the new semantic model created at (3)
 5. Use NodeModelUtils to locate the INode for the "new element"
 6. Use String manipulation to insert the comment before/after the "new element" using offsets from the node model.

Then parse the result again (now the node model knows about the
comments) and then serialize it with formatting turned on. Then it is at
least as pretty as what can be done with the formatter.

If you combine an adapter with the above suggestion, as you iterate over
the node model, you can also get the semantic object. If that semantic
object has an adapter with a comment, you output comments (according to
some convention (before or after the element, etc.)).