1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
package com.github.shyiko.ktlint.ruleset.standard
import com.github.shyiko.ktlint.core.Rule
import org.jetbrains.kotlin.KtNodeTypes
import org.jetbrains.kotlin.com.intellij.lang.ASTNode
import org.jetbrains.kotlin.com.intellij.psi.PsiComment
import org.jetbrains.kotlin.com.intellij.psi.PsiElement
import org.jetbrains.kotlin.com.intellij.psi.impl.source.tree.LeafPsiElement
import org.jetbrains.kotlin.com.intellij.psi.impl.source.tree.PsiWhiteSpaceImpl
import org.jetbrains.kotlin.com.intellij.psi.tree.TokenSet
import org.jetbrains.kotlin.lexer.KtTokens
import org.jetbrains.kotlin.lexer.KtTokens.ANDAND
import org.jetbrains.kotlin.lexer.KtTokens.DIV
import org.jetbrains.kotlin.lexer.KtTokens.DOT
import org.jetbrains.kotlin.lexer.KtTokens.ELVIS
import org.jetbrains.kotlin.lexer.KtTokens.MINUS
import org.jetbrains.kotlin.lexer.KtTokens.MUL
import org.jetbrains.kotlin.lexer.KtTokens.OROR
import org.jetbrains.kotlin.lexer.KtTokens.PERC
import org.jetbrains.kotlin.lexer.KtTokens.PLUS
import org.jetbrains.kotlin.lexer.KtTokens.SAFE_ACCESS
import org.jetbrains.kotlin.psi.psiUtil.nextLeaf
import org.jetbrains.kotlin.psi.psiUtil.prevLeaf
class ChainWrappingRule : Rule("chain-wrapping") {
private val sameLineTokens = TokenSet.create(MUL, DIV, PERC, ANDAND, OROR)
private val prefixTokens = TokenSet.create(PLUS, MINUS)
private val nextLineTokens = TokenSet.create(DOT, SAFE_ACCESS, ELVIS)
private val noSpaceAroundTokens = TokenSet.create(DOT, SAFE_ACCESS)
override fun visit(
node: ASTNode,
autoCorrect: Boolean,
emit: (offset: Int, errorMessage: String, canBeAutoCorrected: Boolean) -> Unit
) {
/*
org.jetbrains.kotlin.com.intellij.psi.impl.source.tree.LeafPsiElement (DOT) | "."
org.jetbrains.kotlin.com.intellij.psi.impl.source.tree.PsiWhiteSpaceImpl (WHITE_SPACE) | "\n "
org.jetbrains.kotlin.psi.KtCallExpression (CALL_EXPRESSION)
*/
val elementType = node.elementType
if (nextLineTokens.contains(elementType)) {
if (node.psi.isPartOf(PsiComment::class)) {
return
}
val nextLeaf = node.psi.nextLeafIgnoringWhitespaceAndComments()?.prevLeaf(true)
if (nextLeaf is PsiWhiteSpaceImpl && nextLeaf.textContains('\n')) {
emit(node.startOffset, "Line must not end with \"${node.text}\"", true)
if (autoCorrect) {
// rewriting
// <prevLeaf><node="."><nextLeaf="\n"> to
// <prevLeaf><delete space if any><nextLeaf="\n"><node="."><space if needed>
// (or)
// <prevLeaf><node="."><spaceBeforeComment><comment><nextLeaf="\n"> to
// <prevLeaf><delete space if any><spaceBeforeComment><comment><nextLeaf="\n"><node="."><space if needed>
val prevLeaf = node.psi.prevLeaf(true)
if (prevLeaf is PsiWhiteSpaceImpl) {
prevLeaf.node.treeParent.removeChild(prevLeaf.node)
}
if (!noSpaceAroundTokens.contains(elementType)) {
nextLeaf.rawInsertAfterMe(PsiWhiteSpaceImpl(" "))
}
node.treeParent.removeChild(node)
nextLeaf.rawInsertAfterMe(node.psi as LeafPsiElement)
}
}
} else if (sameLineTokens.contains(elementType) || prefixTokens.contains(elementType)) {
if (node.psi.isPartOf(PsiComment::class)) {
return
}
val prevLeaf = node.psi.prevLeaf(true)
if (
prevLeaf is PsiWhiteSpaceImpl &&
prevLeaf.textContains('\n') &&
// fn(*typedArray<...>()) case
(elementType != MUL || !prevLeaf.isPartOfSpread()) &&
// unary +/-
(!prefixTokens.contains(elementType) || !node.isInPrefixPosition()) &&
// LeafPsiElement->KtOperationReferenceExpression->KtPrefixExpression->KtWhenConditionWithExpression
!node.isPartOfWhenCondition()
) {
emit(node.startOffset, "Line must not begin with \"${node.text}\"", true)
if (autoCorrect) {
// rewriting
// <insertionPoint><prevLeaf="\n"><node="&&"><nextLeaf=" "> to
// <insertionPoint><prevLeaf=" "><node="&&"><nextLeaf="\n"><delete node="&&"><delete nextLeaf=" ">
// (or)
// <insertionPoint><spaceBeforeComment><comment><prevLeaf="\n"><node="&&"><nextLeaf=" "> to
// <insertionPoint><space if needed><node="&&"><spaceBeforeComment><comment><prevLeaf="\n"><delete node="&&"><delete nextLeaf=" ">
val nextLeaf = node.psi.nextLeaf(true)
if (nextLeaf is PsiWhiteSpaceImpl) {
nextLeaf.node.treeParent.removeChild(nextLeaf.node)
}
val insertionPoint = prevLeaf.prevLeafIgnoringWhitespaceAndComments() as LeafPsiElement
node.treeParent.removeChild(node)
insertionPoint.rawInsertAfterMe(node.psi as LeafPsiElement)
if (!noSpaceAroundTokens.contains(elementType)) {
insertionPoint.rawInsertAfterMe(PsiWhiteSpaceImpl(" "))
}
}
}
}
}
private fun PsiElement.isPartOfSpread() =
prevLeafIgnoringWhitespaceAndComments()?.let { leaf ->
val type = leaf.node.elementType
type == KtTokens.LPAR ||
type == KtTokens.COMMA ||
type == KtTokens.LBRACE ||
type == KtTokens.ELSE_KEYWORD ||
KtTokens.OPERATIONS.contains(type)
} == true
private fun ASTNode.isInPrefixPosition() =
treeParent?.treeParent?.elementType == KtNodeTypes.PREFIX_EXPRESSION
private fun ASTNode.isPartOfWhenCondition() =
treeParent?.treeParent?.treeParent?.elementType == KtNodeTypes.WHEN_CONDITION_EXPRESSION
private fun PsiElement.nextLeafIgnoringWhitespaceAndComments() =
this.nextLeaf { it.node.elementType != KtTokens.WHITE_SPACE && !it.isPartOf(PsiComment::class) }
private fun PsiElement.prevLeafIgnoringWhitespaceAndComments() =
this.prevLeaf { it.node.elementType != KtTokens.WHITE_SPACE && !it.isPartOf(PsiComment::class) }
}
|
