azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Methods for editing in JetValueArgumentList

Browse Source
This commit is contained in:
Valentin Kipyatkov
2015-05-16 16:58:43 +03:00
parent 1e60c24134
commit 25e323e960
12 changed files with 162 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/kotlin/psi/EditCommaSeparatedListHelper.kt
+83
View File
@@ -0,0 +1,83 @@
/*
* Copyright 2010-2015 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 org.jetbrains.kotlin.psi
import com.intellij.psi.PsiComment
import com.intellij.psi.PsiWhiteSpace
import org.jetbrains.kotlin.lexer.JetTokens
import org.jetbrains.kotlin.psi.psiUtil.siblings
private object EditCommaSeparatedListHelper {
public fun <TItem: JetElement> addItem(list: JetElement, allItems: List<TItem>, item: TItem): TItem {
return addItemBefore(list, allItems, item, null)
}
public fun <TItem: JetElement> addItemAfter(list: JetElement, allItems: List<TItem>, item: TItem, anchor: TItem?): TItem {
assert(anchor == null || anchor.getParent() == list)
if (allItems.isEmpty()) {
if (list.getFirstChild().getNode().getElementType() == JetTokens.LPAR) {
return list.addAfter(item, list.getFirstChild()) as TItem
}
else {
return list.add(item) as TItem
}
}
else {
var comma = JetPsiFactory(list).createComma()
if (anchor != null) {
comma = list.addAfter(comma, anchor)
return list.addAfter(item, comma) as TItem
}
else {
comma = list.addBefore(comma, allItems.first())
return list.addBefore(item, comma) as TItem
}
}
}
public fun <TItem: JetElement> addItemBefore(list: JetElement, allItems: List<TItem>, item: TItem, anchor: TItem?): TItem {
val anchorAfter: TItem?
if (allItems.isEmpty()) {
assert(anchor == null)
anchorAfter = null
}
else {
if (anchor != null) {
val index = allItems.indexOf(anchor)
assert(index >= 0)
anchorAfter = if (index > 0) allItems.get(index - 1) else null
}
else {
anchorAfter = allItems.get(allItems.size() - 1)
}
}
return addItemAfter(list, allItems, item, anchorAfter)
}
public fun <TItem: JetElement> removeItem(item: TItem) {
var comma = item.siblings(withItself = false).firstOrNull { it !is PsiWhiteSpace && it !is PsiComment }
if (comma?.getNode()?.getElementType() != JetTokens.COMMA) {
comma = item.siblings(forward = false, withItself = false).firstOrNull { it !is PsiWhiteSpace && it !is PsiComment }
if (comma?.getNode()?.getElementType() != JetTokens.COMMA) {
comma = null
}
}
item.delete()
comma?.delete()
}
}
compiler/frontend/src/org/jetbrains/kotlin/psi/JetParameterList.java
+7 -39
View File
@@ -47,53 +47,21 @@ public class JetParameterList extends JetElementImplStub<KotlinPlaceHolderStub<J
@NotNull
public JetParameter addParameter(@NotNull JetParameter parameter) {
return addParameterBefore(parameter, null);
return EditCommaSeparatedListHelper.INSTANCE$.addItem(this, getParameters(), parameter);
}
@NotNull
public JetParameter addParameterAfter(@NotNull JetParameter parameter, @Nullable JetParameter anchor) {
assert anchor == null || anchor.getParent() == this;
List<JetParameter> parameters = getParameters();
if (parameters.isEmpty()) {
if (getFirstChild().getNode().getElementType() == JetTokens.LPAR) {
return (JetParameter) addAfter(parameter, getFirstChild());
}
else {
return (JetParameter) add(parameter);
}
}
else {
PsiElement comma = new JetPsiFactory(getProject()).createComma();
if (anchor != null) {
comma = addAfter(comma, anchor);
return (JetParameter) addAfter(parameter, comma);
}
else {
comma = addBefore(comma, parameters.get(0));
return (JetParameter) addBefore(parameter, comma);
}
}
return EditCommaSeparatedListHelper.INSTANCE$.addItemAfter(this, getParameters(), parameter, anchor);
}
@NotNull
public JetParameter addParameterBefore(@NotNull JetParameter parameter, @Nullable JetParameter anchor) {
List<JetParameter> parameters = getParameters();
JetParameter anchorAfter;
if (parameters.isEmpty()) {
assert anchor == null;
anchorAfter = null;
}
else {
if (anchor != null) {
int index = parameters.indexOf(anchor);
assert index >= 0;
anchorAfter = index > 0 ? parameters.get(index - 1) : null;
}
else {
anchorAfter = parameters.get(parameters.size() - 1);
}
}
return addParameterAfter(parameter, anchorAfter);
return EditCommaSeparatedListHelper.INSTANCE$.addItemBefore(this, getParameters(), parameter, anchor);
}
public void removeParameter(@NotNull JetParameter parameter) {
EditCommaSeparatedListHelper.INSTANCE$.removeItem(parameter);
}
// this method needed only for migrate lambda syntax
compiler/frontend/src/org/jetbrains/kotlin/psi/JetPsiUtil.java
-32
View File
@@ -24,8 +24,6 @@ import com.intellij.psi.PsiComment;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiFile;
import com.intellij.psi.PsiWhiteSpace;
import com.intellij.psi.impl.CheckUtil;
import com.intellij.psi.impl.source.codeStyle.CodeEditUtil;
import com.intellij.psi.tree.IElementType;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.util.codeInsight.CommentUtilCore;
@@ -36,7 +34,6 @@ import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.JetNodeTypes;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.kdoc.psi.api.KDocElement;
import org.jetbrains.kotlin.lexer.JetKeywordToken;
import org.jetbrains.kotlin.lexer.JetToken;
import org.jetbrains.kotlin.lexer.JetTokens;
import org.jetbrains.kotlin.name.FqName;
@@ -715,35 +712,6 @@ public class JetPsiUtil {
return null;
}
// Delete given element and all the elements separating it from the neighboring elements of the same class
public static void deleteElementWithDelimiters(@NotNull PsiElement element) {
PsiElement paramBefore = PsiTreeUtil.getPrevSiblingOfType(element, element.getClass());
PsiElement from;
PsiElement to;
if (paramBefore != null) {
from = paramBefore.getNextSibling();
to = element;
}
else {
PsiElement paramAfter = PsiTreeUtil.getNextSiblingOfType(element, element.getClass());
from = element;
to = paramAfter != null ? paramAfter.getPrevSibling() : element;
}
PsiElement parent = element.getParent();
parent.deleteChildRange(from, to);
}
// Delete element if it doesn't contain children of a given type
public static <T extends PsiElement> void deleteChildlessElement(PsiElement element, Class<T> childClass) {
if (PsiTreeUtil.getChildrenOfType(element, childClass) == null) {
element.delete();
}
}
public static PsiElement ascendIfPropertyAccessor(PsiElement element) {
if (element instanceof JetPropertyAccessor) {
return element.getParent();
compiler/frontend/src/org/jetbrains/kotlin/psi/JetValueArgumentList.java
+19
View File
@@ -49,4 +49,23 @@ public class JetValueArgumentList extends JetElementImpl {
public PsiElement getLeftParenthesis() {
return findChildByType(JetTokens.LPAR);
}
@NotNull
public JetValueArgument addArgument(@NotNull JetValueArgument argument) {
return EditCommaSeparatedListHelper.INSTANCE$.addItem(this, getArguments(), argument);
}
@NotNull
public JetValueArgument addArgumentAfter(@NotNull JetValueArgument argument, @Nullable JetValueArgument anchor) {
return EditCommaSeparatedListHelper.INSTANCE$.addItemAfter(this, getArguments(), argument, anchor);
}
@NotNull
public JetValueArgument addArgumentBefore(@NotNull JetValueArgument argument, @Nullable JetValueArgument anchor) {
return EditCommaSeparatedListHelper.INSTANCE$.addItemBefore(this, getArguments(), argument, anchor);
}
public void removeArgument(@NotNull JetValueArgument argument) {
EditCommaSeparatedListHelper.INSTANCE$.removeItem(argument);
}
}
compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/jetPsiUtil.kt
+33 -3
View File
@@ -238,14 +238,44 @@ public fun PsiElement.isExtensionDeclaration(): Boolean {
public fun PsiElement.isObjectLiteral(): Boolean = this is JetObjectDeclaration && isObjectLiteral()
//TODO: git rid of this method
public fun PsiElement.deleteElementAndCleanParent() {
val parent = getParent()
JetPsiUtil.deleteElementWithDelimiters(this)
@suppress("UNCHECKED_CAST")
JetPsiUtil.deleteChildlessElement(parent, this.javaClass)
deleteElementWithDelimiters(this)
deleteChildlessElement(parent, this.javaClass)
}
// Delete element if it doesn't contain children of a given type
private fun <T : PsiElement> deleteChildlessElement(element: PsiElement, childClass: Class<T>) {
if (PsiTreeUtil.getChildrenOfType<T>(element, childClass) == null) {
element.delete()
}
}
// Delete given element and all the elements separating it from the neighboring elements of the same class
private fun deleteElementWithDelimiters(element: PsiElement) {
val paramBefore = PsiTreeUtil.getPrevSiblingOfType<PsiElement>(element, element.javaClass)
val from: PsiElement
val to: PsiElement
if (paramBefore != null) {
from = paramBefore.getNextSibling()
to = element
}
else {
val paramAfter = PsiTreeUtil.getNextSiblingOfType<PsiElement>(element, element.javaClass)
from = element
to = if (paramAfter != null) paramAfter.getPrevSibling() else element
}
val parent = element.getParent()
parent.deleteChildRange(from, to)
}
public fun PsiElement.parameterIndex(): Int {
val parent = getParent()
return when {