Custom Language Indent Follow

You can try to use Indent.getSmartIndent, basically it's a type of indent which tries to collapse multiple indents into single one if proper conditions are met.

It's used in java to format anonymous classes nicely:

foooooooooo(new Runnable() {
              @Override
              public void run() {
              }
            },
            "fooo");

while when there is no second parameter indent is collapsed

foooooooooo(new Runnable() {
  @Override
  public void run() {
  }
});

Thanks for the suggestion.  In this case, SmartIndent results in the same spacing as normal indent, so it unfortunately did not magically solve my problem.  

I ended up with a fairly hacky "solution" that manually parses the file and calculates the amount the indent should be offset to work around the issues I mentioned earlier.  So, in this example, the Indent returned by my Block implementation for the param_3 line ends up being -11 spaces.  

    4 Tab Size
-  14 Number of chars after the first expression.  The extra chars are " (chained (ops"
-   1 Offset for opening paren
= -11 Spaces

It's ugly, but it outputs the desired formating.  I'm willing to throw it all in the garbage if something better comes along, but for now it's the best I've got.

As expected, the hacky solution didn't really work.

It turns out the problem was with Alignment, not Indent, and the fix had to be made in two places.  The first was at the grammar level.  I had to move the expression body to a separate element so it could be indented and aligned independently from the enclosing parentheses.  The second fix was to properly set the parent alignment of child blocks during child block generation.  

// Before
FILE ::= EXPRESSION*
EXPRESSION ::= OPEN_PAREN COMMAND PARAMETER* CLOSE_PAREN
PARAMETER ::= EXPRESSION|LITERAL

// Fixed
FILE ::= EXPRESSION*
EXPRESSION ::= OPEN_PAREN EXPRESSION_BODY CLOSE_PAREN
EXPRESSION_BODY ::= COMMAND PARAMETER*
PARAMETER ::= EXPRESSION|LITERAL

I have exactly the same problem, formatter works well with Ctrl+Alt+L but not properly during editing.

Reading your last post is not clear for me how you solve the problem. Can you give more details? Maybe an extract of the code? Did you work on the Block class? Or in the FormattingModelBuilder?

Thanks in advance for the help!

The main thing that helped was the one I already mentioned.  I modified the definition of my language's grammar in the xxx.bnf file so that parens occupied their own nodes in the AST.  I also ensured the blocks appropriately inherited parent alignment during block generation.  

This is some of the code that helped adjust block indentation.  I have no idea if doing it this way is a good idea.

 private List<MyLangBlock> buildMyLangChildren() {
 myLangSubBlocks = new ArrayList<>();
 ASTNode child = myNode.getFirstChildNode();

 while (child != null) {
 if (child.getElementType() != TokenType.WHITE_SPACE) {
 MyLangBlock block = new MyLangBlock(this, child,
 Wrap.createWrap(WrapType.NONE, false),
 createChildAlignment(child),
 spacingBuilder,
 codeStyleSettings,
 null
 );
 if (child.getElementType().equals(MyLangTypes.PAREN_CLOSE)) {
 adjustCloseParenAlignment(block, block.getExtraUnmatchedCloseParens());
 }
 myLangSubBlocks.add(block);
 }
 child = child.getTreeNext();
 }
 return myLangSubBlocks;
 }
 
 /**
 * The leftmost close paren on a line is aligned with the open paren
 * that matches the rightmost paren on the same line.
 * <p>
 * Example:
 * <p>
 * (let (seq
 * a
 * b
 * ))
 * <p>
 * The first close paren on line 4 is aligned with the first open paren on line 1.
 *
 * @param block
 * @param levels The number of levels up the tree to align with this close paren.
 * This is equal to the number of close parens on this line after this block.
 */
 private void adjustCloseParenAlignment(MyLangBlock block, int levels) {
 Alignment alignment = block.getAlignment();
 // start with the expression containing the close paren
 MyLangBlock parent = block.getParentBlock();

 // If there is only 1 close paren, use normal alignment. Otherwise, find
 // the open paren alignment to use with this close paren.
 while (levels > 1 && parent != null) {

 // Move up to the parent expression
 parent = parent.getParentBlock();

 // Find the next paren expression up the tree
 while (parent != null && !parent.getNode().getElementType().equals(MyLangTypes.PARENEXP)) {
 parent = parent.getParentBlock();
 }

 if (parent != null) {
 // Use the alignment of this parent expression for this close paren
 alignment = parent.getAlignment();
 levels--;
 }
 }
 block.setAlignment(alignment);
 }