From 776b754fde9e6c9f356d5692476ff2b641d66fa1 Mon Sep 17 00:00:00 2001 From: Rustam Vishnyakov Date: Tue, 24 Apr 2018 14:57:32 +0300 Subject: [PATCH] Added formatting mode to Java blocks Needed to distinguish normal formatting from enter handling --- .../lang/java/JavaFormattingModelBuilder.java | 26 +++-- .../psi/formatter/java/AbstractJavaBlock.java | 101 +++++++++++------- .../java/BlockContainingJavaBlock.java | 18 +++- .../psi/formatter/java/BlockFactory.java | 10 +- .../formatter/java/CallChunkBlockBuilder.java | 14 +-- .../java/ChainMethodCallsBlockBuilder.java | 13 +-- .../formatter/java/ChildrenBlocksBuilder.java | 16 ++- .../psi/formatter/java/CodeBlockBlock.java | 5 +- .../java/CommentWithInjectionBlock.java | 5 +- .../psi/formatter/java/DocCommentBlock.java | 9 +- .../psi/formatter/java/ExtendsListBlock.java | 18 ++-- .../psi/formatter/java/LabeledJavaBlock.java | 7 +- .../java/PartialWhitespaceBlock.java | 6 +- .../psi/formatter/java/SimpleJavaBlock.java | 8 +- 14 files changed, 158 insertions(+), 98 deletions(-) diff --git a/java/java-impl/src/com/intellij/lang/java/JavaFormattingModelBuilder.java b/java/java-impl/src/com/intellij/lang/java/JavaFormattingModelBuilder.java index ca617621ca30..efff28126879 100644 --- a/java/java-impl/src/com/intellij/lang/java/JavaFormattingModelBuilder.java +++ b/java/java-impl/src/com/intellij/lang/java/JavaFormattingModelBuilder.java @@ -19,9 +19,7 @@ */ package com.intellij.lang.java; -import com.intellij.formatting.Block; -import com.intellij.formatting.FormattingModel; -import com.intellij.formatting.FormattingModelBuilder; +import com.intellij.formatting.*; import com.intellij.lang.ASTNode; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.util.TextRange; @@ -43,21 +41,37 @@ import com.intellij.psi.impl.source.tree.TreeUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -public class JavaFormattingModelBuilder implements FormattingModelBuilder { +public class JavaFormattingModelBuilder implements FormattingModelBuilderEx { private static final Logger LOG = Logger.getInstance("#com.intellij.lang.java.JavaFormattingModelBuilder"); @Override @NotNull - public FormattingModel createModel(final PsiElement element, final CodeStyleSettings settings) { + public FormattingModel createModel(@NotNull final PsiElement element, + @NotNull final CodeStyleSettings settings, + @NotNull final FormattingMode formattingMode) { final FileElement fileElement = TreeUtil.getFileElement((TreeElement)SourceTreeToPsiMap.psiElementToTree(element)); LOG.assertTrue(fileElement != null, "File element should not be null for " + element); CommonCodeStyleSettings commonSettings = settings.getCommonSettings(JavaLanguage.INSTANCE); JavaCodeStyleSettings customJavaSettings = settings.getCustomSettings(JavaCodeStyleSettings.class); - Block block = AbstractJavaBlock.newJavaBlock(fileElement, commonSettings, customJavaSettings); + Block block = AbstractJavaBlock.newJavaBlock(fileElement, commonSettings, customJavaSettings, formattingMode); FormattingDocumentModelImpl model = FormattingDocumentModelImpl.createOn(element.getContainingFile()); return new PsiBasedFormatterModelWithShiftIndentInside (element.getContainingFile(), block, model); } + @Nullable + @Override + public CommonCodeStyleSettings.IndentOptions getIndentOptionsToUse(@NotNull PsiFile file, + @NotNull FormatTextRanges ranges, + @NotNull CodeStyleSettings settings) { + return null; + } + + @NotNull + @Override + public FormattingModel createModel(PsiElement element, CodeStyleSettings settings) { + return createModel(element, settings, FormattingMode.REFORMAT); + } + @Override public TextRange getRangeAffectingIndent(PsiFile file, int offset, ASTNode elementAtOffset) { return doGetRangeAffectingIndent(elementAtOffset); diff --git a/java/java-impl/src/com/intellij/psi/formatter/java/AbstractJavaBlock.java b/java/java-impl/src/com/intellij/psi/formatter/java/AbstractJavaBlock.java index 540da7ac4ecc..ce62d58d3855 100644 --- a/java/java-impl/src/com/intellij/psi/formatter/java/AbstractJavaBlock.java +++ b/java/java-impl/src/com/intellij/psi/formatter/java/AbstractJavaBlock.java @@ -68,10 +68,12 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo private Map myPreferredWraps; private AbstractJavaBlock myParentBlock; + private final FormattingMode myFormattingMode; + private final BlockFactory myBlockFactory = new BlockFactory() { @Override - public Block createBlock(ASTNode node, Indent indent, Alignment alignment, Wrap wrap) { - return new SimpleJavaBlock(node, wrap, AlignmentStrategy.wrap(alignment), indent, mySettings, myJavaSettings); + public Block createBlock(ASTNode node, Indent indent, Alignment alignment, Wrap wrap, @NotNull FormattingMode formattingMode) { + return new SimpleJavaBlock(node, wrap, AlignmentStrategy.wrap(alignment), indent, mySettings, myJavaSettings, formattingMode); } @Override @@ -83,6 +85,11 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo public JavaCodeStyleSettings getJavaSettings() { return myJavaSettings; } + + @Override + public FormattingMode getFormattingMode() { + return myFormattingMode; + } }; protected AbstractJavaBlock(@NotNull final ASTNode node, @@ -90,9 +97,10 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo final Alignment alignment, final Indent indent, @NotNull final CommonCodeStyleSettings settings, - @NotNull JavaCodeStyleSettings javaSettings) + @NotNull JavaCodeStyleSettings javaSettings, + @NotNull FormattingMode formattingMode) { - this(node, wrap, indent, settings, javaSettings, JavaWrapManager.INSTANCE, AlignmentStrategy.wrap(alignment)); + this(node, wrap, indent, settings, javaSettings, JavaWrapManager.INSTANCE, AlignmentStrategy.wrap(alignment), formattingMode); } protected AbstractJavaBlock(@NotNull final ASTNode node, @@ -100,14 +108,16 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo @NotNull final AlignmentStrategy alignmentStrategy, final Indent indent, @NotNull final CommonCodeStyleSettings settings, - @NotNull JavaCodeStyleSettings javaSettings) + @NotNull JavaCodeStyleSettings javaSettings, + @NotNull FormattingMode formattingMode) { - this(node, wrap, indent, settings, javaSettings, JavaWrapManager.INSTANCE, alignmentStrategy); + this(node, wrap, indent, settings, javaSettings, JavaWrapManager.INSTANCE, alignmentStrategy, formattingMode); } private AbstractJavaBlock(@NotNull ASTNode ignored, @NotNull CommonCodeStyleSettings commonSettings, - @NotNull JavaCodeStyleSettings javaSettings) { + @NotNull JavaCodeStyleSettings javaSettings, + @NotNull FormattingMode formattingMode) { super(ignored, null, null); mySettings = commonSettings; myJavaSettings = javaSettings; @@ -115,6 +125,7 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo myIndent = null; myWrapManager = JavaWrapManager.INSTANCE; myAlignmentStrategy = AlignmentStrategy.getNullStrategy(); + myFormattingMode = formattingMode; } protected AbstractJavaBlock(@NotNull final ASTNode node, @@ -123,7 +134,8 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo @NotNull final CommonCodeStyleSettings settings, @NotNull JavaCodeStyleSettings javaSettings, final JavaWrapManager wrapManager, - @NotNull final AlignmentStrategy alignmentStrategy) { + @NotNull final AlignmentStrategy alignmentStrategy, + @NotNull final FormattingMode formattingMode) { super(node, wrap, createBlockAlignment(alignmentStrategy, node)); mySettings = settings; myJavaSettings = javaSettings; @@ -131,6 +143,7 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo myIndent = indent; myWrapManager = wrapManager; myAlignmentStrategy = alignmentStrategy; + myFormattingMode = formattingMode; } @Nullable @@ -149,8 +162,9 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo @NotNull JavaCodeStyleSettings javaSettings, @Nullable Indent indent, @Nullable Wrap wrap, - Alignment alignment) { - return createJavaBlock(child, settings, javaSettings,indent, wrap, AlignmentStrategy.wrap(alignment)); + Alignment alignment, + @NotNull FormattingMode formattingMode) { + return createJavaBlock(child, settings, javaSettings,indent, wrap, AlignmentStrategy.wrap(alignment), formattingMode); } @NotNull @@ -159,8 +173,9 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo @NotNull JavaCodeStyleSettings javaSettings, final Indent indent, @Nullable Wrap wrap, - @NotNull AlignmentStrategy alignmentStrategy) { - return createJavaBlock(child, settings, javaSettings, indent, wrap, alignmentStrategy, -1); + @NotNull AlignmentStrategy alignmentStrategy, + @NotNull FormattingMode formattingMode) { + return createJavaBlock(child, settings, javaSettings, indent, wrap, alignmentStrategy, -1, formattingMode); } @NotNull @@ -170,7 +185,8 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo @Nullable Indent indent, Wrap wrap, @NotNull AlignmentStrategy alignmentStrategy, - int startOffset) { + int startOffset, + @NotNull FormattingMode formattingMode) { Indent actualIndent = indent == null ? getDefaultSubtreeIndent(child, getJavaIndentOptions(settings)) : indent; IElementType elementType = child.getElementType(); Alignment alignment = alignmentStrategy.getAlignment(elementType); @@ -182,26 +198,26 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo int end = CharArrayUtil.shiftBackward(text, text.length() - 1, " \t\n") + 1; LOG.assertTrue(start < end); TextRange range = new TextRange(start + child.getStartOffset(), end + child.getStartOffset()); - return new PartialWhitespaceBlock(child, range, wrap, alignment, actualIndent, settings, javaSettings); + return new PartialWhitespaceBlock(child, range, wrap, alignment, actualIndent, settings, javaSettings, myFormattingMode); } if (childPsi instanceof PsiClass || childPsi instanceof PsiJavaModule) { - return new CodeBlockBlock(child, wrap, alignment, actualIndent, settings, javaSettings); + return new CodeBlockBlock(child, wrap, alignment, actualIndent, settings, javaSettings, formattingMode); } if (child.getElementType() == JavaElementType.METHOD) { - return new BlockContainingJavaBlock(child, actualIndent, alignmentStrategy, mySettings, myJavaSettings); + return new BlockContainingJavaBlock(child, actualIndent, alignmentStrategy, mySettings, myJavaSettings, formattingMode); } if (isBlockType(elementType)) { - return new BlockContainingJavaBlock(child, wrap, alignment, actualIndent, settings, javaSettings); + return new BlockContainingJavaBlock(child, wrap, alignment, actualIndent, settings, javaSettings, formattingMode); } if (isStatement(child, child.getTreeParent())) { - return new CodeBlockBlock(child, wrap, alignment, actualIndent, settings, javaSettings); + return new CodeBlockBlock(child, wrap, alignment, actualIndent, settings, javaSettings, myFormattingMode); } if (!isBuildIndentsOnly() && child instanceof PsiComment && child instanceof PsiLanguageInjectionHost && InjectedLanguageUtil.hasInjections((PsiLanguageInjectionHost)child)) { - return new CommentWithInjectionBlock(child, wrap, alignment, indent, settings, javaSettings); + return new CommentWithInjectionBlock(child, wrap, alignment, indent, settings, javaSettings, formattingMode); } if (child instanceof LeafElement || childPsi instanceof PsiJavaModuleReferenceElement) { if (child.getElementType() == JavaTokenType.C_STYLE_COMMENT) { @@ -212,19 +228,19 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo return block; } if (isLikeExtendsList(elementType)) { - return new ExtendsListBlock(child, wrap, alignmentStrategy, settings, javaSettings); + return new ExtendsListBlock(child, wrap, alignmentStrategy, settings, javaSettings, formattingMode); } if (elementType == JavaElementType.CODE_BLOCK) { - return new CodeBlockBlock(child, wrap, alignment, actualIndent, settings, javaSettings); + return new CodeBlockBlock(child, wrap, alignment, actualIndent, settings, javaSettings, formattingMode); } if (elementType == JavaElementType.LABELED_STATEMENT) { - return new LabeledJavaBlock(child, wrap, alignment, actualIndent, settings, javaSettings); + return new LabeledJavaBlock(child, wrap, alignment, actualIndent, settings, javaSettings, formattingMode); } if (elementType == JavaDocElementType.DOC_COMMENT) { - return new DocCommentBlock(child, wrap, alignment, actualIndent, settings, javaSettings); + return new DocCommentBlock(child, wrap, alignment, actualIndent, settings, javaSettings, formattingMode); } - final SimpleJavaBlock simpleJavaBlock = new SimpleJavaBlock(child, wrap, alignmentStrategy, actualIndent, settings, javaSettings); + final SimpleJavaBlock simpleJavaBlock = new SimpleJavaBlock(child, wrap, alignmentStrategy, actualIndent, settings, javaSettings, myFormattingMode); simpleJavaBlock.setStartOffset(startOffset); return simpleJavaBlock; } @@ -232,9 +248,10 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo @NotNull public static Block newJavaBlock(@NotNull ASTNode child, @NotNull CommonCodeStyleSettings settings, - @NotNull JavaCodeStyleSettings javaSettings) { + @NotNull JavaCodeStyleSettings javaSettings, + @NotNull FormattingMode formattingMode) { final Indent indent = getDefaultSubtreeIndent(child, getJavaIndentOptions(settings)); - return newJavaBlock(child, settings, javaSettings, indent, null, AlignmentStrategy.getNullStrategy()); + return newJavaBlock(child, settings, javaSettings, indent, null, AlignmentStrategy.getNullStrategy(), formattingMode); } @NotNull @@ -243,13 +260,14 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo @NotNull JavaCodeStyleSettings javaSettings, @Nullable Indent indent, @Nullable Wrap wrap, - @NotNull AlignmentStrategy strategy) { - return new AbstractJavaBlock(child, settings, javaSettings) { + @NotNull AlignmentStrategy strategy, + @NotNull FormattingMode formattingMode) { + return new AbstractJavaBlock(child, settings, javaSettings, formattingMode) { @Override protected List buildChildren() { return null; } - }.createJavaBlock(child, settings, javaSettings, indent, wrap, strategy); + }.createJavaBlock(child, settings, javaSettings, indent, wrap, strategy, formattingMode); } @NotNull @@ -488,7 +506,7 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo @NotNull ASTNode child, @NotNull AlignmentStrategy alignmentStrategy, final Wrap defaultWrap, - final Indent childIndent, + Indent childIndent, int childOffset) { final IElementType childType = child.getElementType(); if (childType == JavaTokenType.CLASS_KEYWORD || childType == JavaTokenType.INTERFACE_KEYWORD) { @@ -564,11 +582,11 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo || childType == JavaElementType.DECLARATION_STATEMENT && (nodeType == JavaElementType.METHOD || nodeType == JavaElementType.CODE_BLOCK)) { - result.add(new SimpleJavaBlock(child, defaultWrap, alignmentStrategy, childIndent, mySettings, myJavaSettings)); + result.add(new SimpleJavaBlock(child, defaultWrap, alignmentStrategy, childIndent, mySettings, myJavaSettings, myFormattingMode)); } else if (childType == JavaElementType.METHOD) { Wrap wrap = arrangeChildWrap(child, defaultWrap); - Block block = createJavaBlock(child, mySettings, myJavaSettings, childIndent, wrap, alignmentStrategy); + Block block = createJavaBlock(child, mySettings, myJavaSettings, childIndent, wrap, alignmentStrategy, myFormattingMode); result.add(block); } else { @@ -584,7 +602,7 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo Wrap wrap = arrangeChildWrap(child, defaultWrap); - Block block = createJavaBlock(child, mySettings, myJavaSettings, childIndent, wrap, alignmentStrategyToUse, childOffset); + Block block = createJavaBlock(child, mySettings, myJavaSettings, childIndent, wrap, alignmentStrategyToUse, childOffset, myFormattingMode); if (block instanceof AbstractJavaBlock) { final AbstractJavaBlock javaBlock = (AbstractJavaBlock)block; @@ -644,7 +662,7 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo final Indent childIndent) { ASTNode lastFieldInGroup = findLastFieldInGroup(child); if (lastFieldInGroup == child) { - result.add(createJavaBlock(child, getSettings(), myJavaSettings, childIndent, arrangeChildWrap(child, defaultWrap), alignmentStrategy)); + result.add(createJavaBlock(child, getSettings(), myJavaSettings, childIndent, arrangeChildWrap(child, defaultWrap), alignmentStrategy, myFormattingMode)); return child; } else { @@ -655,7 +673,8 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo child, getSettings(), myJavaSettings, Indent.getContinuationWithoutFirstIndent(myIndentSettings.USE_RELATIVE_INDENTS), arrangeChildWrap(child, defaultWrap), - alignmentStrategy + alignmentStrategy, + myFormattingMode ) ); } @@ -710,7 +729,7 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo private Block createMethodCallExpressionBlock(@NotNull ASTNode node, Wrap blockWrap, Alignment alignment, Indent indent) { final ArrayList nodes = new ArrayList<>(); collectNodes(nodes, node); - return new ChainMethodCallsBlockBuilder(alignment, blockWrap, indent, mySettings, myJavaSettings).build(nodes); + return new ChainMethodCallsBlockBuilder(alignment, blockWrap, indent, mySettings, myJavaSettings, myFormattingMode).build(nodes); } private static void collectNodes(@NotNull List nodes, @NotNull ASTNode node) { @@ -905,13 +924,13 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo child.getElementType() == JavaElementType.EMPTY_EXPRESSION; if (!FormatterUtil.containsWhiteSpacesOnly(child) && child.getTextLength() > 0) { if (child.getElementType() == from) { - result.add(createJavaBlock(child, mySettings, myJavaSettings, externalIndent, null, bracketAlignment)); + result.add(createJavaBlock(child, mySettings, myJavaSettings, externalIndent, null, bracketAlignment, myFormattingMode)); } else if (child.getElementType() == to) { Block block = createJavaBlock(child, mySettings, myJavaSettings, isAfterIncomplete && !afterAnonymousClass ? internalIndent : externalIndent, null, - isAfterIncomplete ? alignmentStrategy.getAlignment(null) : bracketAlignment); + isAfterIncomplete ? alignmentStrategy.getAlignment(null) : bracketAlignment, myFormattingMode); result.add(block); return child; } @@ -1003,7 +1022,7 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo while (child != null) { if (!FormatterUtil.containsWhiteSpacesOnly(child) && child.getTextLength() > 0) { result.add(createJavaBlock(child, mySettings, myJavaSettings, Indent.getNormalIndent(), - wrappingStrategy.getWrap(child.getElementType()), AlignmentStrategy.getNullStrategy())); + wrappingStrategy.getWrap(child.getElementType()), AlignmentStrategy.getNullStrategy(), myFormattingMode)); if (child == last) return child; } child = child.getTreeNext(); @@ -1270,4 +1289,8 @@ public abstract class AbstractJavaBlock extends AbstractBlock implements JavaBlo result.setChildAttributes(new ChildAttributes(getCodeBlockInternalIndent(childrenIndent), null)); return result; } + + protected FormattingMode getFormattingMode() { + return myFormattingMode; + } } \ No newline at end of file diff --git a/java/java-impl/src/com/intellij/psi/formatter/java/BlockContainingJavaBlock.java b/java/java-impl/src/com/intellij/psi/formatter/java/BlockContainingJavaBlock.java index 5222b11ee226..4ddc8034fa93 100644 --- a/java/java-impl/src/com/intellij/psi/formatter/java/BlockContainingJavaBlock.java +++ b/java/java-impl/src/com/intellij/psi/formatter/java/BlockContainingJavaBlock.java @@ -18,7 +18,9 @@ package com.intellij.psi.formatter.java; import com.intellij.formatting.*; import com.intellij.formatting.alignment.AlignmentStrategy; import com.intellij.lang.ASTNode; -import com.intellij.psi.*; +import com.intellij.psi.JavaTokenType; +import com.intellij.psi.PsiStatement; +import com.intellij.psi.PsiTypeElement; import com.intellij.psi.codeStyle.CommonCodeStyleSettings; import com.intellij.psi.codeStyle.JavaCodeStyleSettings; import com.intellij.psi.formatter.FormatterUtil; @@ -50,12 +52,18 @@ public class BlockContainingJavaBlock extends AbstractJavaBlock{ Alignment alignment, Indent indent, CommonCodeStyleSettings settings, - JavaCodeStyleSettings javaSettings) { - super(node, wrap, alignment, indent, settings, javaSettings); + JavaCodeStyleSettings javaSettings, + @NotNull FormattingMode formattingMode) { + super(node, wrap, alignment, indent, settings, javaSettings, formattingMode); } - public BlockContainingJavaBlock(ASTNode child, Indent indent, AlignmentStrategy strategy, CommonCodeStyleSettings settings, JavaCodeStyleSettings javaSettings) { - super(child, null, strategy, indent, settings, javaSettings); + public BlockContainingJavaBlock(ASTNode child, + Indent indent, + AlignmentStrategy strategy, + CommonCodeStyleSettings settings, + JavaCodeStyleSettings javaSettings, + @NotNull FormattingMode formattingMode) { + super(child, null, strategy, indent, settings, javaSettings, formattingMode); } @Override diff --git a/java/java-impl/src/com/intellij/psi/formatter/java/BlockFactory.java b/java/java-impl/src/com/intellij/psi/formatter/java/BlockFactory.java index 3069d2339065..e6df56e49f63 100644 --- a/java/java-impl/src/com/intellij/psi/formatter/java/BlockFactory.java +++ b/java/java-impl/src/com/intellij/psi/formatter/java/BlockFactory.java @@ -15,20 +15,20 @@ */ package com.intellij.psi.formatter.java; -import com.intellij.formatting.Alignment; -import com.intellij.formatting.Block; -import com.intellij.formatting.Indent; -import com.intellij.formatting.Wrap; +import com.intellij.formatting.*; import com.intellij.lang.ASTNode; import com.intellij.psi.codeStyle.CommonCodeStyleSettings; import com.intellij.psi.codeStyle.JavaCodeStyleSettings; +import org.jetbrains.annotations.NotNull; public interface BlockFactory { - Block createBlock(ASTNode node, Indent indent, Alignment alignment, Wrap wrap); + Block createBlock(ASTNode node, Indent indent, Alignment alignment, Wrap wrap, @NotNull FormattingMode formattingMode); CommonCodeStyleSettings getSettings(); JavaCodeStyleSettings getJavaSettings(); + FormattingMode getFormattingMode(); + } diff --git a/java/java-impl/src/com/intellij/psi/formatter/java/CallChunkBlockBuilder.java b/java/java-impl/src/com/intellij/psi/formatter/java/CallChunkBlockBuilder.java index e7aa9179d46b..f3cdd76847a3 100644 --- a/java/java-impl/src/com/intellij/psi/formatter/java/CallChunkBlockBuilder.java +++ b/java/java-impl/src/com/intellij/psi/formatter/java/CallChunkBlockBuilder.java @@ -15,10 +15,7 @@ */ package com.intellij.psi.formatter.java; -import com.intellij.formatting.Alignment; -import com.intellij.formatting.Block; -import com.intellij.formatting.Indent; -import com.intellij.formatting.Wrap; +import com.intellij.formatting.*; import com.intellij.formatting.alignment.AlignmentStrategy; import com.intellij.lang.ASTNode; import com.intellij.psi.JavaTokenType; @@ -37,11 +34,14 @@ public class CallChunkBlockBuilder { private final CommonCodeStyleSettings mySettings; private final CommonCodeStyleSettings.IndentOptions myIndentSettings; private final JavaCodeStyleSettings myJavaSettings; + private final FormattingMode myFormattingMode; - public CallChunkBlockBuilder(@NotNull CommonCodeStyleSettings settings, @NotNull JavaCodeStyleSettings javaSettings) { + public CallChunkBlockBuilder(@NotNull CommonCodeStyleSettings settings, @NotNull JavaCodeStyleSettings javaSettings, + @NotNull FormattingMode formattingMode) { mySettings = settings; myIndentSettings = settings.getIndentOptions(); myJavaSettings = javaSettings; + myFormattingMode = formattingMode; } @NotNull @@ -50,7 +50,7 @@ public class CallChunkBlockBuilder { final ASTNode firstNode = subNodes.get(0); if (firstNode.getElementType() == JavaTokenType.DOT) { AlignmentStrategy strategy = AlignmentStrategy.getNullStrategy(); - Block block = newJavaBlock(firstNode, mySettings, myJavaSettings, Indent.getNoneIndent(), null, strategy); + Block block = newJavaBlock(firstNode, mySettings, myJavaSettings, Indent.getNoneIndent(), null, strategy, myFormattingMode); subBlocks.add(block); subNodes.remove(0); if (!subNodes.isEmpty()) { @@ -66,7 +66,7 @@ public class CallChunkBlockBuilder { final ArrayList result = new ArrayList<>(); for (ASTNode node : subNodes) { Indent indent = Indent.getContinuationWithoutFirstIndent(myIndentSettings.USE_RELATIVE_INDENTS); - result.add(newJavaBlock(node, mySettings, myJavaSettings, indent, null, AlignmentStrategy.getNullStrategy())); + result.add(newJavaBlock(node, mySettings, myJavaSettings, indent, null, AlignmentStrategy.getNullStrategy(), myFormattingMode)); } return result; } diff --git a/java/java-impl/src/com/intellij/psi/formatter/java/ChainMethodCallsBlockBuilder.java b/java/java-impl/src/com/intellij/psi/formatter/java/ChainMethodCallsBlockBuilder.java index a1d9e1ff7fed..50f71af7cc25 100644 --- a/java/java-impl/src/com/intellij/psi/formatter/java/ChainMethodCallsBlockBuilder.java +++ b/java/java-impl/src/com/intellij/psi/formatter/java/ChainMethodCallsBlockBuilder.java @@ -15,10 +15,7 @@ */ package com.intellij.psi.formatter.java; -import com.intellij.formatting.Alignment; -import com.intellij.formatting.Block; -import com.intellij.formatting.Indent; -import com.intellij.formatting.Wrap; +import com.intellij.formatting.*; import com.intellij.lang.ASTNode; import com.intellij.psi.JavaTokenType; import com.intellij.psi.PsiComment; @@ -41,11 +38,14 @@ class ChainMethodCallsBlockBuilder { private final Alignment myBlockAlignment; private final Indent myBlockIndent; + private final FormattingMode myFormattingMode; + public ChainMethodCallsBlockBuilder(Alignment alignment, Wrap wrap, Indent indent, CommonCodeStyleSettings settings, - JavaCodeStyleSettings javaSettings) + JavaCodeStyleSettings javaSettings, + @NotNull FormattingMode formattingMode) { myBlockWrap = wrap; myBlockAlignment = alignment; @@ -53,6 +53,7 @@ class ChainMethodCallsBlockBuilder { mySettings = settings; myIndentSettings = settings.getIndentOptions(); myJavaSettings = javaSettings; + myFormattingMode = formattingMode; } public Block build(List nodes) { @@ -85,7 +86,7 @@ class ChainMethodCallsBlockBuilder { chainedCallsAlignment = null; } - CallChunkBlockBuilder builder = new CallChunkBlockBuilder(mySettings, myJavaSettings); + CallChunkBlockBuilder builder = new CallChunkBlockBuilder(mySettings, myJavaSettings, myFormattingMode); blocks.add(builder.create(currentCallChunk.nodes, wrap, chainedCallsAlignment)); } diff --git a/java/java-impl/src/com/intellij/psi/formatter/java/ChildrenBlocksBuilder.java b/java/java-impl/src/com/intellij/psi/formatter/java/ChildrenBlocksBuilder.java index 680d79183e1d..0605c2abb08b 100644 --- a/java/java-impl/src/com/intellij/psi/formatter/java/ChildrenBlocksBuilder.java +++ b/java/java-impl/src/com/intellij/psi/formatter/java/ChildrenBlocksBuilder.java @@ -15,10 +15,7 @@ */ package com.intellij.psi.formatter.java; -import com.intellij.formatting.Alignment; -import com.intellij.formatting.Block; -import com.intellij.formatting.Indent; -import com.intellij.formatting.Wrap; +import com.intellij.formatting.*; import com.intellij.lang.ASTNode; import com.intellij.openapi.util.Condition; import com.intellij.psi.formatter.FormatterUtil; @@ -50,7 +47,7 @@ public class ChildrenBlocksBuilder { Indent indent = myConfig.getIndent(type); Wrap wrap = myConfig.getWrap(type); - blocks.add(factory.createBlock(child, indent, alignment, wrap)); + blocks.add(factory.createBlock(child, indent, alignment, wrap, factory.getFormattingMode())); } return blocks; @@ -69,6 +66,7 @@ public class ChildrenBlocksBuilder { private Alignment myDefaultAlignment; private Indent myDefaultIndent; private Wrap myDefaultWrap; + private FormattingMode myFormattingMode; public ChildrenBlocksBuilder createBuilder() { return new ChildrenBlocksBuilder(this); @@ -140,5 +138,13 @@ public class ChildrenBlocksBuilder { return this; } + public FormattingMode getFormattingMode() { + return myFormattingMode; + } + + public Config setFormattingMode(FormattingMode formattingMode) { + myFormattingMode = formattingMode; + return this; + } } } diff --git a/java/java-impl/src/com/intellij/psi/formatter/java/CodeBlockBlock.java b/java/java-impl/src/com/intellij/psi/formatter/java/CodeBlockBlock.java index 6188e7fad4c4..fcdb50e1d89c 100644 --- a/java/java-impl/src/com/intellij/psi/formatter/java/CodeBlockBlock.java +++ b/java/java-impl/src/com/intellij/psi/formatter/java/CodeBlockBlock.java @@ -45,8 +45,9 @@ public class CodeBlockBlock extends AbstractJavaBlock { Alignment alignment, Indent indent, CommonCodeStyleSettings settings, - JavaCodeStyleSettings javaSettings) { - super(node, wrap, getAlignmentStrategy(alignment, node, settings), indent, settings, javaSettings); + JavaCodeStyleSettings javaSettings, + @NotNull FormattingMode formattingMode) { + super(node, wrap, getAlignmentStrategy(alignment, node, settings), indent, settings, javaSettings, formattingMode); if (isSwitchCodeBlock() && !settings.INDENT_CASE_FROM_SWITCH) { myChildrenIndent = 0; } diff --git a/java/java-impl/src/com/intellij/psi/formatter/java/CommentWithInjectionBlock.java b/java/java-impl/src/com/intellij/psi/formatter/java/CommentWithInjectionBlock.java index 1689af999e45..f93d8062fd42 100644 --- a/java/java-impl/src/com/intellij/psi/formatter/java/CommentWithInjectionBlock.java +++ b/java/java-impl/src/com/intellij/psi/formatter/java/CommentWithInjectionBlock.java @@ -38,8 +38,9 @@ public class CommentWithInjectionBlock extends AbstractJavaBlock { Alignment alignment, Indent indent, CommonCodeStyleSettings settings, - JavaCodeStyleSettings javaSettings) { - super(node, wrap, alignment, indent, settings, javaSettings); + JavaCodeStyleSettings javaSettings, + @NotNull FormattingMode formattingMode) { + super(node, wrap, alignment, indent, settings, javaSettings, formattingMode); myInjectedBlockBuilder = new JavaCommentInjectedBlockBuilder(); } diff --git a/java/java-impl/src/com/intellij/psi/formatter/java/DocCommentBlock.java b/java/java-impl/src/com/intellij/psi/formatter/java/DocCommentBlock.java index 90c76f07d6ae..b5d3ef0f7266 100644 --- a/java/java-impl/src/com/intellij/psi/formatter/java/DocCommentBlock.java +++ b/java/java-impl/src/com/intellij/psi/formatter/java/DocCommentBlock.java @@ -33,9 +33,10 @@ public class DocCommentBlock extends AbstractJavaBlock{ Alignment alignment, Indent indent, CommonCodeStyleSettings settings, - JavaCodeStyleSettings javaSettings) + JavaCodeStyleSettings javaSettings, + @NotNull FormattingMode formattingMode) { - super(node, wrap, alignment, indent, settings, javaSettings); + super(node, wrap, alignment, indent, settings, javaSettings, formattingMode); } @Override @@ -45,9 +46,9 @@ public class DocCommentBlock extends AbstractJavaBlock{ ASTNode child = myNode.getFirstChildNode(); while (child != null) { if (child.getElementType() == JavaDocTokenType.DOC_COMMENT_START) { - result.add(createJavaBlock(child, mySettings, myJavaSettings, Indent.getNoneIndent(), null, AlignmentStrategy.getNullStrategy())); + result.add(createJavaBlock(child, mySettings, myJavaSettings, Indent.getNoneIndent(), null, AlignmentStrategy.getNullStrategy(), getFormattingMode())); } else if (!FormatterUtil.containsWhiteSpacesOnly(child) && !child.getText().trim().isEmpty()){ - result.add(createJavaBlock(child, mySettings, myJavaSettings, Indent.getSpaceIndent(1), null, AlignmentStrategy.getNullStrategy())); + result.add(createJavaBlock(child, mySettings, myJavaSettings, Indent.getSpaceIndent(1), null, AlignmentStrategy.getNullStrategy(), getFormattingMode())); } child = child.getTreeNext(); } diff --git a/java/java-impl/src/com/intellij/psi/formatter/java/ExtendsListBlock.java b/java/java-impl/src/com/intellij/psi/formatter/java/ExtendsListBlock.java index 777c7ad5d101..00d889653b83 100644 --- a/java/java-impl/src/com/intellij/psi/formatter/java/ExtendsListBlock.java +++ b/java/java-impl/src/com/intellij/psi/formatter/java/ExtendsListBlock.java @@ -15,10 +15,7 @@ */ package com.intellij.psi.formatter.java; -import com.intellij.formatting.Alignment; -import com.intellij.formatting.Block; -import com.intellij.formatting.Indent; -import com.intellij.formatting.Wrap; +import com.intellij.formatting.*; import com.intellij.formatting.alignment.AlignmentStrategy; import com.intellij.lang.ASTNode; import com.intellij.psi.JavaTokenType; @@ -28,6 +25,7 @@ import com.intellij.psi.formatter.FormatterUtil; import com.intellij.psi.impl.source.tree.ElementType; import com.intellij.psi.impl.source.tree.JavaElementType; import com.intellij.psi.tree.IElementType; +import org.jetbrains.annotations.NotNull; import java.util.ArrayList; import java.util.List; @@ -37,18 +35,20 @@ public class ExtendsListBlock extends AbstractJavaBlock{ Wrap wrap, Alignment alignment, CommonCodeStyleSettings settings, - JavaCodeStyleSettings javaSettings) + JavaCodeStyleSettings javaSettings, + @NotNull FormattingMode formattingMode) { - super(node, wrap, alignment, Indent.getNoneIndent(), settings, javaSettings); + super(node, wrap, alignment, Indent.getNoneIndent(), settings, javaSettings, formattingMode); } public ExtendsListBlock(ASTNode node, Wrap wrap, AlignmentStrategy alignmentStrategy, CommonCodeStyleSettings settings, - JavaCodeStyleSettings javaSettings) + JavaCodeStyleSettings javaSettings, + @NotNull FormattingMode formattingMode) { - super(node, wrap, alignmentStrategy, Indent.getNoneIndent(), settings, javaSettings); + super(node, wrap, alignmentStrategy, Indent.getNoneIndent(), settings, javaSettings, formattingMode); } @Override @@ -74,7 +74,7 @@ public class ExtendsListBlock extends AbstractJavaBlock{ Indent indent = mySettings.ALIGN_THROWS_KEYWORD && elementType == JavaTokenType.THROWS_KEYWORD ? Indent.getNoneIndent() : myChildIndent; - result.add(createJavaBlock(child, mySettings, myJavaSettings, indent, arrangeChildWrap(child, childWrap), alignment)); + result.add(createJavaBlock(child, mySettings, myJavaSettings, indent, arrangeChildWrap(child, childWrap), alignment, getFormattingMode())); } else { Alignment candidate = myAlignmentStrategy.getAlignment(elementType); if (candidate != null) { diff --git a/java/java-impl/src/com/intellij/psi/formatter/java/LabeledJavaBlock.java b/java/java-impl/src/com/intellij/psi/formatter/java/LabeledJavaBlock.java index 6e969420d016..7148b0652689 100644 --- a/java/java-impl/src/com/intellij/psi/formatter/java/LabeledJavaBlock.java +++ b/java/java-impl/src/com/intellij/psi/formatter/java/LabeledJavaBlock.java @@ -34,8 +34,9 @@ public class LabeledJavaBlock extends AbstractJavaBlock{ Alignment alignment, Indent indent, CommonCodeStyleSettings settings, - JavaCodeStyleSettings javaSettings) { - super(node, wrap, alignment, indent, settings, javaSettings); + JavaCodeStyleSettings javaSettings, + @NotNull FormattingMode formattingMode) { + super(node, wrap, alignment, indent, settings, javaSettings, formattingMode); } @Override @@ -46,7 +47,7 @@ public class LabeledJavaBlock extends AbstractJavaBlock{ Wrap currentWrap = null; while (child != null) { if (!FormatterUtil.containsWhiteSpacesOnly(child) && child.getTextLength() > 0){ - result.add(createJavaBlock(child, mySettings, myJavaSettings, currentIndent, currentWrap, AlignmentStrategy.getNullStrategy())); + result.add(createJavaBlock(child, mySettings, myJavaSettings, currentIndent, currentWrap, AlignmentStrategy.getNullStrategy(), getFormattingMode())); if (child.getElementType() == JavaTokenType.COLON) { currentIndent = Indent.getNoneIndent(); currentWrap =Wrap.createWrap(WrapType.ALWAYS, true); diff --git a/java/java-impl/src/com/intellij/psi/formatter/java/PartialWhitespaceBlock.java b/java/java-impl/src/com/intellij/psi/formatter/java/PartialWhitespaceBlock.java index 652070ea57e2..9aad4fe8d486 100644 --- a/java/java-impl/src/com/intellij/psi/formatter/java/PartialWhitespaceBlock.java +++ b/java/java-impl/src/com/intellij/psi/formatter/java/PartialWhitespaceBlock.java @@ -16,6 +16,7 @@ package com.intellij.psi.formatter.java; import com.intellij.formatting.Alignment; +import com.intellij.formatting.FormattingMode; import com.intellij.formatting.Indent; import com.intellij.formatting.Wrap; import com.intellij.formatting.alignment.AlignmentStrategy; @@ -37,8 +38,9 @@ public class PartialWhitespaceBlock extends SimpleJavaBlock { Alignment alignment, Indent indent, CommonCodeStyleSettings settings, - JavaCodeStyleSettings javaSettings) { - super(node, wrap, AlignmentStrategy.wrap(alignment), indent, settings, javaSettings); + JavaCodeStyleSettings javaSettings, + @NotNull FormattingMode formattingMode) { + super(node, wrap, AlignmentStrategy.wrap(alignment), indent, settings, javaSettings, formattingMode); myRange = range; } diff --git a/java/java-impl/src/com/intellij/psi/formatter/java/SimpleJavaBlock.java b/java/java-impl/src/com/intellij/psi/formatter/java/SimpleJavaBlock.java index 9f132ccb0e47..aba624382a1c 100644 --- a/java/java-impl/src/com/intellij/psi/formatter/java/SimpleJavaBlock.java +++ b/java/java-impl/src/com/intellij/psi/formatter/java/SimpleJavaBlock.java @@ -46,8 +46,9 @@ public class SimpleJavaBlock extends AbstractJavaBlock { AlignmentStrategy alignment, Indent indent, CommonCodeStyleSettings settings, - JavaCodeStyleSettings javaSettings) { - super(node, wrap, alignment, indent, settings, javaSettings); + JavaCodeStyleSettings javaSettings, + @NotNull FormattingMode formattingMode) { + super(node, wrap, alignment, indent, settings, javaSettings, formattingMode); } @Override @@ -118,7 +119,8 @@ public class SimpleJavaBlock extends AbstractJavaBlock { Block commentBlock = createJavaBlock( myCurrentChild, mySettings, myJavaSettings, - Indent.getNoneIndent(), null, AlignmentStrategy.getNullStrategy() + Indent.getNoneIndent(), null, AlignmentStrategy.getNullStrategy(), + getFormattingMode() ); result.add(commentBlock); myCurrentIndent = Indent.getNoneIndent();