/*
* Copyright 2000-2014 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.intellij.formatting.alignment;
import com.intellij.lang.ASTNode;
import com.intellij.openapi.util.Couple;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.impl.source.tree.TreeUtil;
import com.intellij.psi.tree.IElementType;
import com.intellij.psi.tree.TokenSet;
import com.intellij.util.SmartList;
import org.jetbrains.annotations.Nullable;
import java.util.List;
/**
* This class provides helper methods to use for {@code 'align in columns'} processing.
* <p/>
* {@code 'Align in columns'} here means format the code like below:
* <pre>
* class Test {
* private int iii = 1;
* private double d = 2;
* }
* </pre>
* I.e. components of two lines are aligned to each other in columns.
* <p/>
* This class is not singleton but it's thread-safe and provides single-point-of-usage field {@link #INSTANCE}.
* <p/>
* Thread-safe.
*
* @author Denis Zhdanov
* @since May 24, 2010 3:09:52 PM
*/
public class AlignmentInColumnsHelper {
/**
* Single-point-of-usage field.
*/
public static final AlignmentInColumnsHelper INSTANCE = new AlignmentInColumnsHelper();
/**
* Allows to answer if given node should be aligned to the previous node of the same type according to the given alignment config
* assuming that given node is a variable declaration.
*
* @param node target node which alignment strategy is to be defined
* @param config alignment config to use for processing
* @param blankLinesToBeKeptOnReformat corresponding KEEP_LINE_IN_* formatting setting
* @return {@code true} if given node should be aligned to the previous one; {@code false} otherwise
*/
@SuppressWarnings({"MethodMayBeStatic"})
public boolean useDifferentVarDeclarationAlignment(ASTNode node, AlignmentInColumnsConfig config, int blankLinesToBeKeptOnReformat) {
ASTNode prev = getPreviousAdjacentNodeOfTargetType(node, config, blankLinesToBeKeptOnReformat);
if (prev == null) {
return true;
}
ASTNode curr = deriveNodeOfTargetType(node, TokenSet.create(prev.getElementType()));
if (curr == null) {
return true;
}
// The main idea is to avoid alignment like the one below:
// private final int i;
// double d;
// I.e. we want to avoid alignment-implied long indents from the start of line.
// Please note that we do allow alignment like below:
// private final int i;
// private double d;
ASTNode prevSubNode = getSubNodeThatStartsNewLine(prev.getFirstChildNode(), config);
ASTNode currSubNode = getSubNodeThatStartsNewLine(curr.getFirstChildNode(), config);
while (true) {
boolean prevNodeIsDefined = prevSubNode != null;
boolean currNodeIsDefined = currSubNode != null;
// Check if one sub-node starts from new line and another one doesn't start.
if (prevNodeIsDefined ^ currNodeIsDefined) {
return true;
}
if (prevSubNode == null) {
break;
}
if (prevSubNode.getElementType() != currSubNode.getElementType()
/*|| StringUtil.countNewLines(prevSubNode.getChars()) != StringUtil.countNewLines(currSubNode.getChars())*/) {
return true;
}
prevSubNode = getSubNodeThatStartsNewLine(prevSubNode.getTreeNext(), config);
currSubNode = getSubNodeThatStartsNewLine(currSubNode.getTreeNext(), config);
}
// There is a possible declaration like the one below
// int i1 = 1;
// int i2, i3 = 2;
// Three fields are declared here - 'i1', 'i2' and 'i3'. So, the check if field 'i2' contains assignment should be
// performed against 'i3'.
ASTNode currentFieldToUse = curr;
ASTNode nextNode = curr.getTreeNext();
for (; nextNode != null && nextNode.getTreeParent() == curr.getTreeParent(); nextNode = nextNode.getTreeNext()) {
IElementType type = nextNode.getElementType();
if (config.getWhiteSpaceTokenTypes().contains(type)) {
ASTNode previous = nextNode.getTreePrev();
if ((previous != null && previous.getElementType() == curr.getElementType()) || StringUtil.countNewLines(nextNode.getChars()) > 1) {
break;
}
continue;
}
if (config.getCommentTokenTypes().contains(type)) {
continue;
}
if (type == curr.getElementType()) {
currentFieldToUse = nextNode;
}
}
List<IElementType> prevTypes = findSubNodeTypes(prev, config.getDistinguishableTypes());
List<IElementType> currTypes = findSubNodeTypes(currentFieldToUse, config.getDistinguishableTypes());
return !prevTypes.equals(currTypes);
}
/**
* Tries to find previous node adjacent to the given node that has the same
* {@link AlignmentInColumnsConfig#getTargetDeclarationTypes() target type}.
*
* @param baseNode base node to use
* @param config current processing config
* @param blankLinesToBeKeptOnReformat
* @return previous node to the given base node that has that same type and is adjacent to it if possible;
* {@code null} otherwise
*/
@SuppressWarnings({"StatementWithEmptyBody"})
@Nullable
private static ASTNode getPreviousAdjacentNodeOfTargetType(ASTNode baseNode,
AlignmentInColumnsConfig config,
final double blankLinesToBeKeptOnReformat) {
ASTNode nodeOfTargetType = deriveNodeOfTargetType(baseNode, config.getTargetDeclarationTypes());
if (nodeOfTargetType == null) {
return null;
}
final ASTNode[] prev = new ASTNode[1];
findPreviousNode(config, baseNode, new NodeProcessor() {
@Override
public boolean targetTypeFound(ASTNode node) {
prev[0] = node;
return true;
}
@Override
public boolean whitespaceFound(ASTNode node) {
return blankLinesToBeKeptOnReformat > 0 && StringUtil.countChars(node.getText(), '\n') > 1;
}
});
if (prev[0] == null) return null;
// ensure there are no non-whitespace, non-comment elements on the top level between baseNode and the found one
Couple<ASTNode> siblingParents = TreeUtil.findTopmostSiblingParents(prev[0], baseNode);
if (siblingParents.first != null && siblingParents.second != null) {
for (ASTNode each = siblingParents.second.getTreePrev(); each != null && each != siblingParents.first; each = each.getTreePrev()) {
IElementType eachType = each.getElementType();
if (!config.getCommentTokenTypes().contains(eachType) && !config.getWhiteSpaceTokenTypes().contains(eachType)) return null;
}
}
return deriveNodeOfTargetType(prev[0], TokenSet.create(nodeOfTargetType.getElementType()));
}
/**
* There is a possible case that given base node doesn't have {@link AlignmentInColumnsConfig#getTargetDeclarationTypes() target type}
* but its first child node or first child node of the first child node etc does.
* <p/>
* This method tries to derive node of the target type from the given node.
*
* @param baseNode base node to process
* @param targetTypes target node types
* @return base node or its first descendant child that has
* {@link AlignmentInColumnsConfig#getTargetDeclarationTypes() target type} target type if the one if found;
* {@code null} otherwise
*/
@Nullable
private static ASTNode deriveNodeOfTargetType(ASTNode baseNode, TokenSet targetTypes) {
if (targetTypes.contains(baseNode.getElementType())) {
return baseNode;
}
for (ASTNode node = baseNode; node != null; node = node.getFirstChildNode()) {
IElementType nodeType = node.getElementType();
if (targetTypes.contains(nodeType)) {
return node;
}
}
return null;
}
/**
* Shorthand for calling {@link #findPreviousNode(AlignmentInColumnsConfig, ASTNode, NodeProcessor)} with the type of
* the given node as a target type.
*
* @param config configuration to use
* @param from start node to use
* @param processor
* @return true if the processor has returned true for one of the processed nodes, false otherwise
*/
private static boolean findPreviousNode(AlignmentInColumnsConfig config, ASTNode from, NodeProcessor processor) {
return findPreviousNode(config, from, from.getElementType(), false, true, processor);
}
/**
* Tries to find node that is direct or indirect previous node of the given node.
* <p/>
* E.g. there is a possible use-case:
* <pre>
* n1
* / \
* n21 n22
* | |
* n31 n32
* </pre>
* Let's assume that target node is {@code 'n32'}. 'n31' is assumed to be returned from this method then.
* <p/>
* <b>Note:</b> current method avoids going too deep if found node type is the same as start node type
*
* @return direct or indirect previous node of the given one having target type if possible; {@code null} otherwise
*/
private static boolean findPreviousNode(AlignmentInColumnsConfig config,
ASTNode from,
IElementType targetType,
boolean processFrom,
boolean processParent,
NodeProcessor processor) {
if (from == null) return false;
for (ASTNode prev = processFrom ? from : from.getTreePrev(); prev != null; prev = prev.getTreePrev()) {
IElementType prevType = prev.getElementType();
if (prevType == targetType) {
if (processor.targetTypeFound(prev)) return true;
}
else if (config.getWhiteSpaceTokenTypes().contains(prevType)) {
if (processor.whitespaceFound(prev)) return true;
}
if (findPreviousNode(config, prev.getLastChildNode(), targetType, true, false, processor)) return true;
}
if (processParent) {
for (ASTNode parent = from.getTreeParent(); parent != null; parent = parent.getTreeParent()) {
if (findPreviousNode(config, parent, targetType, false, false, processor)) return true;
}
}
return false;
}
private static abstract class NodeProcessor {
public boolean targetTypeFound(ASTNode node) {
return false;
}
public boolean whitespaceFound(ASTNode node) {
return false;
}
}
@SuppressWarnings({"StatementWithEmptyBody"})
@Nullable
private static ASTNode getSubNodeThatStartsNewLine(@Nullable ASTNode startNode, AlignmentInColumnsConfig config) {
if (startNode == null) {
return null;
}
ASTNode parent = startNode.getTreeParent();
if (parent == null) {
// Never expect to be here.
return null;
}
// Check if previous node to the start node is white space that contains line feeds.
final boolean[] returnFirstNonEmptySubNode = {false};
findPreviousNode(config, startNode, new NodeProcessor() {
@Override
public boolean targetTypeFound(ASTNode node) {
return true;
}
@Override
public boolean whitespaceFound(ASTNode node) {
return returnFirstNonEmptySubNode[0] = StringUtil.countNewLines(node.getChars()) > 0;
}
});
boolean stop = false;
for (ASTNode result = startNode; result != null && result.getTreeParent() == parent; result = result.getTreeNext()) {
if (config.getStopMultilineCheckElementTypes().contains(result.getElementType())) {
return null;
}
if (result.getTextLength() <= 0) {
continue;
}
if (config.getCommentTokenTypes().contains(result.getElementType())) {
continue;
}
if (config.getWhiteSpaceTokenTypes().contains(result.getElementType()) && StringUtil.countNewLines(result.getChars()) > 0) {
stop = true;
continue;
}
if (returnFirstNonEmptySubNode[0]) {
return result;
}
if (stop) {
return result;
}
}
return null;
}
private static List<IElementType> findSubNodeTypes(ASTNode node, TokenSet types) {
List<IElementType> foundTypes = new SmartList<>();
for (ASTNode child = node.getFirstChildNode(); child != null && child.getTreeParent() == node; child = child.getTreeNext()) {
IElementType type = child.getElementType();
if (types.contains(type)) {
foundTypes.add(type);
}
}
return foundTypes;
}
}