MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2026-09-27 10:03:11 +07:00
Code Issues Packages Projects Releases Wiki Activity

Revert "IDEA-87315 The freemarker code style should respect the XML identation setting instead of forcing 4 space identation"

Browse Source 
This reverts commit debb180ea4.
This commit is contained in:
Denis.Zhdanov
2012-06-26 16:12:54 +04:00
parent 720ae9faa5
commit bc985c8b73
3 changed files with 40 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files
platform/lang-impl/src/com/intellij/formatting/AbstractBlockWrapper.java
+9 -49
View File
@@ -16,12 +16,8 @@
package com.intellij.formatting;
import com.intellij.lang.ASTNode;
import com.intellij.lang.Language;
import com.intellij.openapi.util.TextRange;
import com.intellij.psi.PsiElement;
import com.intellij.psi.codeStyle.CommonCodeStyleSettings;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.ArrayList;
@@ -40,53 +36,31 @@ public abstract class AbstractBlockWrapper {
Indent.Type.NORMAL, Indent.Type.CONTINUATION, Indent.Type.CONTINUATION_WITHOUT_FIRST
));
protected WhiteSpace myWhiteSpace;
protected WhiteSpace myWhiteSpace;
protected CompositeBlockWrapper myParent;
protected int myStart;
protected int myEnd;
protected int myFlags;
protected int myStart;
protected int myEnd;
protected int myFlags;
static int CAN_USE_FIRST_CHILD_INDENT_AS_BLOCK_INDENT = 1;
static int INCOMPLETE = 2;
private final Language myLanguage;
static int INCOMPLETE = 2;
protected IndentInfo myIndentFromParent = null;
private IndentImpl myIndent = null;
private IndentImpl myIndent = null;
private AlignmentImpl myAlignment;
private WrapImpl myWrap;
private WrapImpl myWrap;
public AbstractBlockWrapper(final Block block,
final WhiteSpace whiteSpace,
final CompositeBlockWrapper parent,
final TextRange textRange) {
public AbstractBlockWrapper(final Block block, final WhiteSpace whiteSpace, final CompositeBlockWrapper parent, final TextRange textRange) {
myWhiteSpace = whiteSpace;
myParent = parent;
myStart = textRange.getStartOffset();
myEnd = textRange.getEndOffset();
myFlags = CAN_USE_FIRST_CHILD_INDENT_AS_BLOCK_INDENT | (block.isIncomplete() ? INCOMPLETE : 0);
myFlags = CAN_USE_FIRST_CHILD_INDENT_AS_BLOCK_INDENT | (block.isIncomplete() ? INCOMPLETE:0);
myAlignment = (AlignmentImpl)block.getAlignment();
myWrap = (WrapImpl)block.getWrap();
myLanguage = deriveLanguage(block);
}
@Nullable
private static Language deriveLanguage(@NotNull Block block) {
if (block instanceof ASTBlock) {
final ASTNode node = ((ASTBlock)block).getNode();
if (node == null) {
return null;
}
final PsiElement psi = node.getPsi();
if (psi == null) {
return null;
}
return psi.getLanguage();
}
return null;
}
public WhiteSpace getWhiteSpace() {
return myWhiteSpace;
}
@@ -115,20 +89,6 @@ public abstract class AbstractBlockWrapper {
return myEnd - myStart;
}
/**
* There is a possible case that particular block's language differs from the language implied by the file type. We need to
* distinguish such a situation because, for example in case of indent calculation (code style settings for different languages
* may have different indent values).
* <p/>
* This method allows to retrieve the language associated with the current block (if provided).
*
* @return current block's language (if provided)
*/
@Nullable
public Language getLanguage() {
return myLanguage;
}
/**
* Applies given start offset to the current block wrapper and recursively calls this method on parent block wrapper
* if it starts at the same place as the current one.
platform/lang-impl/src/com/intellij/formatting/FormatProcessor.java
+18 -43
View File
@@ -16,7 +16,6 @@
package com.intellij.formatting;
import com.intellij.lang.Language;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.editor.Document;
import com.intellij.openapi.editor.TextChange;
@@ -43,7 +42,7 @@ class FormatProcessor {
ALIGNMENT_PROCESSORS.put(Alignment.Anchor.LEFT, new LeftEdgeAlignmentProcessor());
ALIGNMENT_PROCESSORS.put(Alignment.Anchor.RIGHT, new RightEdgeAlignmentProcessor());
}
/**
* There is a possible case that formatting introduced big number of changes to the underlying document. That number may be
* big enough for that their subsequent appliance is much slower than direct replacing of the whole document text.
@@ -51,7 +50,7 @@ class FormatProcessor {
* Current constant holds minimum number of changes that should trigger such <code>'replace whole text'</code> optimization.
*/
private static final int BULK_REPLACE_OPTIMIZATION_CRITERIA = 3000;
private static final Logger LOG = Logger.getInstance("#com.intellij.formatting.FormatProcessor");
private LeafBlockWrapper myCurrentBlock;
@@ -60,9 +59,9 @@ class FormatProcessor {
private CompositeBlockWrapper myRootBlockWrapper;
private TIntObjectHashMap<LeafBlockWrapper> myTextRangeToWrapper;
private final CommonCodeStyleSettings.IndentOptions myDefaultIndentOption;
private final CodeStyleSettings mySettings;
private final Document myDocument;
private final CommonCodeStyleSettings.IndentOptions myIndentOption;
private final CodeStyleSettings mySettings;
private final Document myDocument;
/**
* Remembers mappings between backward-shifted aligned block and blocks that cause that shift in order to detect
@@ -83,7 +82,7 @@ class FormatProcessor {
private final Map<LeafBlockWrapper, Set<LeafBlockWrapper>> myBackwardShiftedAlignedBlocks
= new HashMap<LeafBlockWrapper, Set<LeafBlockWrapper>>();
private final Map<AbstractBlockWrapper, Set<AbstractBlockWrapper>> myAlignmentMappings
private final Map<AbstractBlockWrapper, Set<AbstractBlockWrapper>> myAlignmentMappings
= new HashMap<AbstractBlockWrapper, Set<AbstractBlockWrapper>>();
/**
@@ -168,7 +167,7 @@ class FormatProcessor {
@NotNull FormattingProgressCallback progressCallback)
{
myProgressCallback = progressCallback;
myDefaultIndentOption = indentOptions;
myIndentOption = indentOptions;
mySettings = settings;
myDocument = docModel.getDocument();
myCurrentState = new WrapBlocksState(rootBlock, docModel, affectedRanges, interestingOffset);
@@ -321,8 +320,8 @@ class FormatProcessor {
* <code>false</code> otherwise
*/
@SuppressWarnings({"deprecation"})
private boolean applyChangesAtBulkMode(final List<LeafBlockWrapper> blocksToModify, final FormattingModel model,
@NotNull CommonCodeStyleSettings.IndentOptions indentOption)
private static boolean applyChangesAtBulkMode(final List<LeafBlockWrapper> blocksToModify, final FormattingModel model,
CommonCodeStyleSettings.IndentOptions indentOption)
{
FormattingDocumentModel documentModel = model.getDocumentModel();
Document document = documentModel.getDocument();
@@ -336,8 +335,7 @@ class FormatProcessor {
for (LeafBlockWrapper block : blocksToModify) {
WhiteSpace whiteSpace = block.getWhiteSpace();
CharSequence newWs = documentModel.adjustWhiteSpaceIfNecessary(
whiteSpace.generateWhiteSpace(getIndentOptionsToUse(block, indentOption)), whiteSpace.getStartOffset(),
whiteSpace.getEndOffset(), false
whiteSpace.generateWhiteSpace(indentOption), whiteSpace.getStartOffset(), whiteSpace.getEndOffset(), false
);
if (changes.size() > 10000) {
CharSequence mergeResult = BulkChangesMerger.INSTANCE.mergeToCharSequence(document.getChars(), document.getTextLength(), changes);
@@ -410,7 +408,7 @@ class FormatProcessor {
for (LeafBlockWrapper block = myFirstTokenBlock; block != null; block = block.getNextBlock()) {
final WhiteSpace whiteSpace = block.getWhiteSpace();
if (!whiteSpace.isReadOnly()) {
final String newWhiteSpace = whiteSpace.generateWhiteSpace(getIndentOptionsToUse(block, myDefaultIndentOption));
final String newWhiteSpace = whiteSpace.generateWhiteSpace(myIndentOption);
if (!whiteSpace.equalsToString(newWhiteSpace)) {
blocksToModify.add(block);
}
@@ -419,22 +417,6 @@ class FormatProcessor {
return blocksToModify;
}
@NotNull
private CommonCodeStyleSettings.IndentOptions getIndentOptionsToUse(@NotNull AbstractBlockWrapper block,
@NotNull CommonCodeStyleSettings.IndentOptions fallbackIndentOptions)
{
final Language language = block.getLanguage();
if (language == null) {
return fallbackIndentOptions;
}
final CommonCodeStyleSettings commonSettings = mySettings.getCommonSettings(language);
if (commonSettings == null) {
return fallbackIndentOptions;
}
final CommonCodeStyleSettings.IndentOptions result = commonSettings.getIndentOptions();
return result == null ? fallbackIndentOptions : result;
}
private static TextRange shiftRange(final TextRange textRange, final int shift) {
return new TextRange(textRange.getStartOffset() + shift, textRange.getEndOffset() + shift);
}
@@ -647,8 +629,7 @@ class FormatProcessor {
}
BlockAlignmentProcessor.Context context = new BlockAlignmentProcessor.Context(
myDocument, alignment, myCurrentBlock, myAlignmentMappings, myBackwardShiftedAlignedBlocks,
getIndentOptionsToUse(myCurrentBlock, myDefaultIndentOption)
myDocument, alignment, myCurrentBlock, myAlignmentMappings, myBackwardShiftedAlignedBlocks, myIndentOption
);
BlockAlignmentProcessor.Result result = alignmentProcessor.applyAlignment(context);
final LeafBlockWrapper offsetResponsibleBlock = alignment.getOffsetRespBlockBefore(myCurrentBlock);
@@ -723,7 +704,7 @@ class FormatProcessor {
}
private void adjustSpacingByIndentOffset() {
IndentData offset = myCurrentBlock.calculateOffset(getIndentOptionsToUse(myCurrentBlock, myDefaultIndentOption));
IndentData offset = myCurrentBlock.calculateOffset(myIndentOption);
myCurrentBlock.getWhiteSpace().setSpaces(offset.getSpaces(), offset.getIndentSpaces());
}
@@ -991,7 +972,7 @@ class FormatProcessor {
private IndentInfo adjustLineIndent(final AbstractBlockWrapper parent, final ChildAttributes childAttributes, final int index) {
int alignOffset = getAlignOffsetBefore(childAttributes.getAlignment(), null);
if (alignOffset == -1) {
return parent.calculateChildOffset(getIndentOptionsToUse(parent, myDefaultIndentOption), childAttributes, index).createIndentInfo();
return parent.calculateChildOffset(myIndentOption, childAttributes, index).createIndentInfo();
}
else {
AbstractBlockWrapper indentedParentBlock = CoreFormatterUtil.getIndentedParentBlock(myCurrentBlock);
@@ -1266,7 +1247,7 @@ class FormatProcessor {
super(FormattingStateId.WRAPPING_BLOCKS);
myModel = model;
myWrapper = InitialInfoBuilder.prepareToBuildBlocksSequentially(
root, model, affectedRanges, myDefaultIndentOption, interestingOffset, myProgressCallback
root, model, affectedRanges, myIndentOption, interestingOffset, myProgressCallback
);
}
@@ -1292,7 +1273,7 @@ class FormatProcessor {
myCurrentBlock = myFirstTokenBlock;
myTextRangeToWrapper = buildTextRangeToInfoMap(myFirstTokenBlock);
myLastWhiteSpace = new WhiteSpace(getLastBlock().getEndOffset(), false);
myLastWhiteSpace.append(myModel.getTextLength(), myModel, myDefaultIndentOption);
myLastWhiteSpace.append(myModel.getTextLength(), myModel, myIndentOption);
}
}
@@ -1377,9 +1358,7 @@ class FormatProcessor {
updatedDocument.setInBulkUpdate(true);
myResetBulkUpdateState = true;
}
if (blocksToModifyCount > BULK_REPLACE_OPTIMIZATION_CRITERIA
&& applyChangesAtBulkMode(myBlocksToModify, myModel, myDefaultIndentOption))
{
if (blocksToModifyCount > BULK_REPLACE_OPTIMIZATION_CRITERIA && applyChangesAtBulkMode(myBlocksToModify, myModel, myIndentOption)) {
setDone(true);
}
}
@@ -1388,11 +1367,7 @@ class FormatProcessor {
protected void doIteration() {
LeafBlockWrapper blockWrapper = myBlocksToModify.get(myIndex);
myShift = replaceWhiteSpace(
myModel,
blockWrapper,
myShift,
blockWrapper.getWhiteSpace().generateWhiteSpace(getIndentOptionsToUse(blockWrapper, myDefaultIndentOption)),
myJavaIndentOptions
myModel, blockWrapper, myShift, blockWrapper.getWhiteSpace().generateWhiteSpace(myIndentOption), myJavaIndentOptions
);
myProgressCallback.afterApplyingChange(blockWrapper);
// block could be gc'd
platform/lang-impl/src/com/intellij/formatting/InitialInfoBuilder.java
+13 -10
View File
@@ -185,10 +185,11 @@ class InitialInfoBuilder {
}
private CompositeBlockWrapper buildCompositeBlock(final Block rootBlock,
final CompositeBlockWrapper parent,
final int index,
final WrapImpl currentWrapParent,
boolean rootBlockIsRightBlock) {
final CompositeBlockWrapper parent,
final int index,
final WrapImpl currentWrapParent,
boolean rootBlockIsRightBlock)
{
final CompositeBlockWrapper wrappedRootBlock = new CompositeBlockWrapper(rootBlock, myCurrentWhiteSpace, parent);
if (index == 0) {
wrappedRootBlock.arrangeParentTextRange();
@@ -205,7 +206,7 @@ class InitialInfoBuilder {
blocksMayBeOfInterest = true;
}
final boolean blocksAreReadOnly = rootBlock instanceof ReadOnlyBlockContainer || blocksMayBeOfInterest;
State state = new State(rootBlock, wrappedRootBlock, currentWrapParent, blocksAreReadOnly, rootBlockIsRightBlock);
myStates.push(state);
return wrappedRootBlock;
@@ -236,14 +237,14 @@ class InitialInfoBuilder {
if (!state.readOnly && !(subBlocks instanceof Unmodifiable) && !(subBlocks instanceof ImmutableCollection)) {
subBlocks.set(childBlockIndex, null); // to prevent extra strong refs during model building
}
if (state.childBlockProcessed(block, wrapper)) {
while (!myStates.isEmpty() && myStates.peek().isProcessed()) {
myStates.pop();
}
}
}
private void setDefaultIndents(final List<AbstractBlockWrapper> list) {
if (!list.isEmpty()) {
for (AbstractBlockWrapper wrapper : list) {
@@ -258,7 +259,8 @@ class InitialInfoBuilder {
final CompositeBlockWrapper parent,
final boolean readOnly,
final int index,
Block parentBlock) {
Block parentBlock)
{
LeafBlockWrapper result = doProcessSimpleBlock(rootBlock, parent, readOnly, index, parentBlock);
myProgressCallback.afterWrappingBlock(result);
return result;
@@ -268,7 +270,8 @@ class InitialInfoBuilder {
final CompositeBlockWrapper parent,
final boolean readOnly,
final int index,
Block parentBlock) {
Block parentBlock)
{
if (!INLINE_TABS_ENABLED && !myCurrentWhiteSpace.containsLineFeeds()) {
myCurrentWhiteSpace.setForceSkipTabulationsUsage(true);
}
@@ -360,7 +363,7 @@ class InitialInfoBuilder {
buffer.append("Affected text fragment:[").append(minOffset).append(",").append(maxOffset).append("] - '")
.append(model.getText(new TextRange(minOffset, maxOffset))).append("'\n");
final StringBuilder messageBuffer = new StringBuilder();
final StringBuilder messageBuffer = new StringBuilder();
messageBuffer.append("Invalid ranges during formatting");
if (model instanceof FormattingDocumentModelImpl) {
messageBuffer.append(" in ").append(((FormattingDocumentModelImpl)model).getFile().getLanguage());