Formatting with Java Enhanced Switch Statement

[StrangeRanger]

I found that when attempting to format a Java file that contains an enhanced switch statement, clang-format will only format the code to the switch statement, but nothing below it.

Below is an example code that hasn't been formatted yet, and has an enhanced switch statement. I've also included my configuration file. As a note, I'm using clang-format 14.0.4.

package cs350s22.component.ui.parser;

import cs350s22.component.logger.LoggerMessage;
import cs350s22.component.logger.LoggerMessageSequencing;
import cs350s22.support.Clock;
import cs350s22.support.Filespec;
import java.io.IOException;

/** META command class. */
public class MetaParser implements SubParser {
    String[] cmdTextSplit;
    int            numOfCmdArgs;
    A_ParserHelper parserHelper;

    @Override
    public void parse(String[] cmdTextSplit, A_ParserHelper parserHelper) throws IOException {
        this.cmdTextSplit = cmdTextSplit;
        this.numOfCmdArgs = cmdTextSplit.length - 1;
        this.parserHelper = parserHelper;

        switch (cmdTextSplit[0].toUpperCase()) {
            case "@CLOCK" -> setClockHelper();
            case "@EXIT" -> exit();
            case "@RUN" -> run();
            case "@CONFIGURE" -> configure();
            default -> System.out.println("Invalid META command: " + cmdTextSplit[0]);
        }
    }

    ////[ Clock Methods ]///////////////////////////////////////////////////////////////

    /** Parses @CLOCK sub commands, and execute their respective methods. */
    private void setClockHelper() {
        if (numOfCmdArgs == 0) {
            displayClock();
            return;
        }

        String argOne = cmdTextSplit[1].toUpperCase();

        /// @CLOCK (PAUSE | RESUME)
        if (argOne.contains("PAUSE") || argOne.contains("RESUME"))  {
            setClockState(argOne);
        }
        /// @CLOCK ONESTEP [count]
        else if (argOne.contains("ONESTEP")) {
            if (numOfCmdArgs >= 2) {
                setClockOnestep(Integer.parseInt(cmdTextSplit[2]));
            } else {
                setClockOnestep();
            }
        }
        /// META commands that require 2 or more arguments.
        else if (numOfCmdArgs >= 2) {
            String argTwo = cmdTextSplit[2].toUpperCase();

            /// @CLOCK SET RATE value
            if (argOne.contains("SET") && argTwo.contains("RATE")) {
                if (numOfCmdArgs >= 3) {
                    setClockRate(Integer.parseInt(cmdTextSplit[3]));
                } else {
                    System.out.println("Missing argument for @CLOCK SET RATE");
                }
            }
            /// @CLOCK WAIT FOR value
            else if (argOne.contains("WAIT") && argTwo.contains("FOR")) {
                if (numOfCmdArgs >= 3) {
                    setClockWaitFor(Double.parseDouble(cmdTextSplit[3]));
                } else {
                    System.out.println("Missing argument for @CLOCK WAIT FOR");
                }
            }
            /// @CLOCK WAIT UNTIL value
            else if (argOne.contains("WAIT") && argTwo.contains("UNTIL")) {
                if (numOfCmdArgs >= 3) {
                    setClockWaitUntil(Double.parseDouble(cmdTextSplit[3]));
                } else {
                    System.out.println("Missing argument for @CLOCK WAIT UNTIL");
                }
            } else {
                System.out.println("Invalid arguments for @CLOCK: " + argOne + " " + argTwo);
            }
        }
        /// Anything else.
        else {
            System.out.println("Invalid argument for @CLOCK: " + argOne);
        }
    }

    /** Display clock time. */
    private void displayClock() {
        System.out.println(Clock.getInstance().getTime());
    }

    /**
     * Set the state of the clock to either 'RESUME' or 'PAUSE'.
     *
     * @param arg The state the clock should be set to.
     */
    private void setClockState(String arg) {
        Clock.getInstance().isActive(arg.contains("RESUME"));
    }

    /**
     *
     */
    private void setClockOnestep() {
        if (Clock.getInstance().isActive()) {
            System.out.println("Clock must be paused to use this command");
        } else {
            Clock.getInstance().onestep();
        }
    }

    /**
     *
     * @param onestep
     */
    private void setClockOnestep(int onestep) {
        if (Clock.getInstance().isActive()) {
            System.out.println("Clock must be paused to use this command");
        } else {
            Clock.getInstance().onestep(onestep);
        }
    }

    /**
     *
     * @param rate
     */
    private void setClockRate(int rate) {
        Clock.getInstance().setRate(rate);
    }

    /**
     *
     * @param value
     */
    private void setClockWaitFor(double value) {
        Clock.getInstance().waitFor(value);
    }

    /**
     *
     * @param value
     */
    private void setClockWaitUntil(double value) {
        Clock.getInstance().waitUntil(value);
    }

    ////[ Non-Clock Methods ]///////////////////////////////////////////////////////////

    /**
     *
     */
    private void exit() {
        //parserHelper.exit(); // TODO: Uncomment when ready...
        System.exit(0);
    }

    /**
     *
     */
    private void run() {
        try {
            parserHelper.run(cmdTextSplit[1]);
        } catch (ParseException | IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * TODO: Possibly refactor/modify.
     */
    private void configure() throws IOException {
        String log = null, dotSequence = null, network = null, xml = null;

        /// For statement only goes up to the second to last index in array on purpose.
        for (int i = 1; i < numOfCmdArgs; i++) {
            String cmdArg = cmdTextSplit[i].toUpperCase();
            String cmdArgPrevious = cmdTextSplit[i-1].toUpperCase();

            if (cmdArg.contains("LOG")) {
                log = cmdTextSplit[i+1];
            } else if (cmdArgPrevious.contains("DOT") && cmdArg.contains("SEQUENCE")) {
                dotSequence = cmdTextSplit[i+1];
            } else if (cmdArg.contains("NETWORK")) {
                network = cmdTextSplit[i+1];
            } else if (cmdArg.contains("XML")) {
                xml = cmdTextSplit[i+1];;
            }
        }

        if (log != null && dotSequence != null && network != null) {
            LoggerMessage.initialize(Filespec.make(log));
            LoggerMessageSequencing.initialize(Filespec.make(dotSequence),
                                               Filespec.make(network));
        } else {
            throw new IOException("One or more required arguments is either missing or incorrect for @CONFIGURE");
        }
    }
}

---
Language:        Java
# BasedOnStyle:  Chromium
AccessModifierOffset: -1
AlignAfterOpenBracket: Align
AlignArrayOfStructures: None
AlignConsecutiveMacros: Consecutive
AlignConsecutiveAssignments: Consecutive
AlignConsecutiveBitFields: Consecutive
AlignConsecutiveDeclarations: Consecutive
AlignEscapedNewlines: Left
AlignOperands:   Align
AlignTrailingComments: true
AllowAllArgumentsOnNextLine: false  # Maybe: Do some testing
AllowAllParametersOfDeclarationOnNextLine: false # Maybe: Do some testing
AllowShortEnumsOnASingleLine: true  # Maybe
AllowShortBlocksOnASingleLine: Empty
AllowShortCaseLabelsOnASingleLine: false # Maybe
AllowShortFunctionsOnASingleLine: All
AllowShortLambdasOnASingleLine: All
AllowShortIfStatementsOnASingleLine: Never # Maybe
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: MultiLine
AttributeMacros:
  - __capability
BinPackArguments: true
BinPackParameters: true
BraceWrapping:
  AfterCaseLabel:  false
  AfterClass:      false
  AfterControlStatement: Never
  AfterEnum:       false
  AfterFunction:   false
  AfterNamespace:  false
  AfterObjCDeclaration: false
  AfterStruct:     false
  AfterUnion:      false
  AfterExternBlock: false
  BeforeCatch:     false
  BeforeElse:      false
  BeforeLambdaBody: false
  BeforeWhile:     false
  IndentBraces:    false
  SplitEmptyFunction: true
  SplitEmptyRecord: true
  SplitEmptyNamespace: true
BreakBeforeBinaryOperators: NonAssignment  # OR None
BreakBeforeConceptDeclarations: true
BreakBeforeBraces: Attach
BreakBeforeInheritanceComma: false
BreakInheritanceList: BeforeColon  # OR AfterComma
BreakBeforeTernaryOperators: true  # Maybe
BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: BeforeColon  # OR AfterColon
BreakAfterJavaFieldAnnotations: true
BreakStringLiterals: true
ColumnLimit:     88
CommentPragmas:  '^ IWYU pragma:'
QualifierAlignment: Leave  # Maybe (WARNING: Warning provided on website)
CompactNamespaces: false  # Maybe
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 8
Cpp11BracedListStyle: true
DeriveLineEnding: true
DerivePointerAlignment: false
DisableFormat:   false
EmptyLineAfterAccessModifier: Leave
EmptyLineBeforeAccessModifier: LogicalBlock
ExperimentalAutoDetectBinPacking: false
PackConstructorInitializers: NextLine  # OR BinPack
FixNamespaceComments: false
ForEachMacros:
  - foreach
  - Q_FOREACH
  - BOOST_FOREACH
IfMacros:
  - KJ_IF_MAYBE
IncludeBlocks:   Merge
IncludeCategories:
  - Regex:           '^<ext/.*\.h>'
    Priority:        2
    SortPriority:    0
    CaseSensitive:   false
  - Regex:           '^<.*\.h>'
    Priority:        1
    SortPriority:    0
    CaseSensitive:   false
  - Regex:           '^<.*'
    Priority:        2
    SortPriority:    0
    CaseSensitive:   false
  - Regex:           '.*'
    Priority:        3
    SortPriority:    0
    CaseSensitive:   false
IncludeIsMainRegex: '([-_](test|unittest))?$'
IncludeIsMainSourceRegex: ''
IndentAccessModifiers: false
IndentCaseLabels: true
IndentCaseBlocks: false
IndentGotoLabels: true
IndentPPDirectives: AfterHash
IndentExternBlock: Indent
IndentRequires:  false  # Maybe
IndentWidth:     4
IndentWrappedFunctionNames: true
InsertTrailingCommas: None
JavaScriptQuotes: Double
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: false
LambdaBodyIndentation: OuterScope
MacroBlockBegin: ''
MacroBlockEnd:   ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: All
ObjCBinPackProtocolList: Auto
ObjCBlockIndentWidth: 4
ObjCBreakBeforeNestedBlockParam: true  # TODO
ObjCSpaceAfterProperty: false  # TODO
ObjCSpaceBeforeProtocolList: true  # TODO
PenaltyBreakAssignment: 2  # TODO
PenaltyBreakBeforeFirstCallParameter: 1  # TODO
PenaltyBreakComment: 300  # TODO
PenaltyBreakFirstLessLess: 120  # TODO
PenaltyBreakOpenParenthesis: 120  # TODO
PenaltyBreakString: 1000  # TODO
PenaltyBreakTemplateDeclaration: 10  # TODO
PenaltyExcessCharacter: 1000000  # TODO
PenaltyReturnTypeOnItsOwnLine: 200  # TODO
PenaltyIndentedWhitespace: 0  # TODO
PointerAlignment: Right
PPIndentWidth:   -1
ReferenceAlignment: Pointer
ReflowComments:  true
RemoveBracesLLVM: false  # Maybe (WARNING: Warning provided on website)
SeparateDefinitionBlocks: Leave  # Maybe
ShortNamespaceLines: 1
SortIncludes:    CaseSensitive
SortJavaStaticImport: Before
SortUsingDeclarations: true
SpaceAfterCStyleCast: true
SpaceAfterLogicalNot: true
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeCaseColon: false
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: Custom
SpaceBeforeParensOptions:
  AfterControlStatements: true
  AfterForeachMacros: true
  AfterFunctionDefinitionName: false
  AfterFunctionDeclarationName: false
  AfterIfMacros:   true
  AfterOverloadedOperator: false
  BeforeNonEmptyParentheses: false
SpaceAroundPointerQualifiers: Default
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyBlock: true
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 2
SpacesInAngles:  Never
SpacesInConditionalStatement: false
SpacesInContainerLiterals: false
SpacesInCStyleCastParentheses: false
SpacesInLineCommentPrefix:
  Minimum:         1
  Maximum:         -1
SpacesInParentheses: false
SpacesInSquareBrackets: false
SpaceBeforeSquareBrackets: false
BitFieldColonSpacing: Both  # Maybe
Standard:        Auto
StatementAttributeLikeMacros:
  - Q_EMIT
StatementMacros:
  - Q_UNUSED
  - QT_REQUIRE_VERSION
TabWidth:        4
UseCRLF:         false
UseTab:          Never
WhitespaceSensitiveMacros:
  - STRINGIZE
  - PP_STRINGIZE
  - BOOST_PP_STRINGIZE
  - NS_SWIFT_NAME
  - CF_SWIFT_NAME
...

[llvmbot]

@llvm/issue-subscribers-clang-format

[mydeveloperday]

Can you make a smaller producer?

[StrangeRanger]

@mydeveloperday Are you asking me for that? If so, what do you mean by producer?

[StrangeRanger]

If you're asking me to shortening the configuration file to specifically reference the configs that aren't working or something, I can't. I have no idea what specific configuration is preventing the formatting after the enhanced switch case. I think it might be more of a parser problem or something. Additionally, I include the whole java file so you can see how it's not formatted to the configuration specifications, after the enhanced switch case.

[mkurdej]

I can reproduce only with:

    public void f() {
        switch (something) {
            case "CASE" -> f();
            default -> g();
        }
    }

  private         void g() {if (condition) {}
    }

and LLVM default style.
Nothing fancy needed whenever there's a switch with -> arrows.

Expected (probably, not sure whether arrows should have newlines before/after or not):

public void f() {
  switch (something) {
  case "CASE" -> f();
  default -> g();
  }
}

private void g() {
  if (condition) {
  }
}

Mind that this is formatted ok:

    public void f() {
        switch (something) {
            case "CASE": f();
            default: g();
        }
    }

  private         void g() {if (condition) {}
    }

Result as expected:

public void f() {
  switch (something) {
  case "CASE":
    f();
  default:
    g();
  }
}

private void g() {
  if (condition) {
  }
}

[llvmbot]

@llvm/issue-subscribers-good-first-issue

[mkurdej]

The problem must be pretty trivial, we only handle colons : after case/default, but not arrows ->, and the parser does not recover.

[eoan-ermine]

I'll work on it

[timmyjose]

Any updates on this?

[bansan85]

I would like to try to fix it but I don't know where to start. I searched on the source code and I found function Parser::ParseSwitchStatement in clang/lib/Parse/ParseStmt.cpp. Is this the good function to patch ?

[pirama-arumuga-nainar]

Any updates/findings on this issue?

Adding clang-format code owners @mydeveloperday @owenca to clarify if the previous comment is in the right direction.

[owenca]

I would like to try to fix it but I don't know where to start. I searched on the source code and I found function Parser::ParseSwitchStatement in clang/lib/Parse/ParseStmt.cpp. Is this the good function to patch ?

I would start from clang/lib/Format/UnwrappedLineParser.cpp.