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

J2K KtQualifiedExpression and subclasses: convert

Browse Source 
Also merge KtQualifiedExpressionImpl into KtQualifiedExpression and remove
calls from subclasses
This commit is contained in:
Alexander Udalov
2016-04-18 15:41:26 +03:00
parent 093c2f63d4
commit fa31994442
5 changed files with 70 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/kotlin/psi/KtDotQualifiedExpression.kt
+43 -68
View File
@@ -14,91 +14,66 @@
* limitations under the License. * limitations under the License.
*/ */
package org.jetbrains.kotlin.psi; package org.jetbrains.kotlin.psi
import com.intellij.lang.ASTNode; import com.intellij.lang.ASTNode
import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.diagnostic.Logger
import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub
import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
import org.jetbrains.kotlin.lexer.KtToken; import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes.INSIDE_DIRECTIVE_EXPRESSIONS
import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes;
import static org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes.INSIDE_DIRECTIVE_EXPRESSIONS; class KtDotQualifiedExpression : KtExpressionImplStub<KotlinPlaceHolderStub<KtDotQualifiedExpression>>, KtQualifiedExpression {
constructor(node: ASTNode) : super(node)
public class KtDotQualifiedExpression extends KtExpressionImplStub<KotlinPlaceHolderStub<KtDotQualifiedExpression>> constructor(stub: KotlinPlaceHolderStub<KtDotQualifiedExpression>) : super(stub, KtStubElementTypes.DOT_QUALIFIED_EXPRESSION)
implements KtQualifiedExpression {
private static final Logger LOG = Logger.getInstance(KtDotQualifiedExpression.class); override fun <R, D> accept(visitor: KtVisitor<R, D>, data: D): R {
return visitor.visitDotQualifiedExpression(this, data)
public KtDotQualifiedExpression(@NotNull ASTNode node) {
super(node);
} }
public KtDotQualifiedExpression(@NotNull KotlinPlaceHolderStub<KtDotQualifiedExpression> stub) { override val receiverExpression: KtExpression
super(stub, KtStubElementTypes.DOT_QUALIFIED_EXPRESSION); get() {
} val stub = stub
if (stub != null) {
@Override val childExpressionsByStub = getChildExpressionsByStub(stub)
public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) { if (childExpressionsByStub != null) {
return visitor.visitDotQualifiedExpression(this, data); return childExpressionsByStub[0]
} }
@NotNull
@Override
public KtExpression getReceiverExpression() {
KotlinPlaceHolderStub<KtDotQualifiedExpression> stub = getStub();
if (stub != null) {
KtExpression[] childExpressionsByStub = getChildExpressionsByStub(stub);
if (childExpressionsByStub != null) {
return childExpressionsByStub[0];
} }
return super.receiverExpression
} }
return KtQualifiedExpressionImpl.INSTANCE.getReceiverExpression(this);
}
@Nullable override val selectorExpression: KtExpression?
@Override get() {
public KtExpression getSelectorExpression() { val stub = stub
KotlinPlaceHolderStub<KtDotQualifiedExpression> stub = getStub(); if (stub != null) {
if (stub != null) { val childExpressionsByStub = getChildExpressionsByStub(stub)
KtExpression[] childExpressionsByStub = getChildExpressionsByStub(stub); if (childExpressionsByStub != null && childExpressionsByStub.size == 2) {
if (childExpressionsByStub != null && childExpressionsByStub.length == 2) { return childExpressionsByStub[1]
return childExpressionsByStub[1]; }
} }
return super.selectorExpression
} }
return KtQualifiedExpressionImpl.INSTANCE.getSelectorExpression(this);
}
private fun getChildExpressionsByStub(stub: KotlinPlaceHolderStub<KtDotQualifiedExpression>): Array<KtExpression>? {
@Nullable if (stub.getParentStubOfType(KtImportDirective::class.java) == null &&
private KtExpression[] getChildExpressionsByStub(@NotNull KotlinPlaceHolderStub<KtDotQualifiedExpression> stub) { stub.getParentStubOfType(KtPackageDirective::class.java) == null) {
if (stub.getParentStubOfType(KtImportDirective.class) == null && stub.getParentStubOfType(KtPackageDirective.class) == null) { LOG.error("KtDotQualifiedExpression should only have stubs inside import or package directives.\n" +
LOG.error("JetDotQualifiedExpression should only have stubs inside import or package directives.\n " + "Stubs were created for:\n$text\nFile text:\n${containingFile.text}")
"Stubs were created for:\n " + getText() + return null
"\nFile text:\n" + getContainingFile().getText());
return null;
} }
else { else {
KtExpression[] expressions = stub.getChildrenByType(INSIDE_DIRECTIVE_EXPRESSIONS, KtExpression.ARRAY_FACTORY); val expressions = stub.getChildrenByType(INSIDE_DIRECTIVE_EXPRESSIONS, KtExpression.ARRAY_FACTORY)
if (expressions.length < 1 || expressions.length > 2) { if (expressions.size < 1 || expressions.size > 2) {
LOG.error("Invalid stub structure. DOT_QUALIFIED_EXPRESSION must have one or two children. Was: " + expressions.length + LOG.error("Invalid stub structure. DOT_QUALIFIED_EXPRESSION must have one or two children. Was: ${expressions.size}\n" +
"\nFile text:\n" + getContainingFile().getText()); "File text:\n${containingFile.text}")
return null; return null
} }
return expressions; return expressions
} }
} }
@NotNull companion object {
@Override private val LOG = Logger.getInstance(KtDotQualifiedExpression::class.java)
public ASTNode getOperationTokenNode() {
return KtQualifiedExpressionImpl.INSTANCE.getOperationTokenNode(this);
}
@NotNull
@Override
public KtToken getOperationSign() {
return KtQualifiedExpressionImpl.INSTANCE.getOperationSign(this);
} }
} }
compiler/frontend/src/org/jetbrains/kotlin/psi/KtQualifiedExpression.kt
+20 -14
View File
@@ -14,23 +14,29 @@
* limitations under the License. * limitations under the License.
*/ */
package org.jetbrains.kotlin.psi; package org.jetbrains.kotlin.psi
import com.intellij.lang.ASTNode; import com.intellij.lang.ASTNode
import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.lexer.KtToken
import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.lexer.KtTokens
import org.jetbrains.kotlin.lexer.KtToken; import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
import org.jetbrains.kotlin.psi.psiUtil.siblings
import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
public interface KtQualifiedExpression extends KtExpression { interface KtQualifiedExpression : KtExpression {
@NotNull val receiverExpression: KtExpression
KtExpression getReceiverExpression(); get() = getExpression(false) ?: throw AssertionError("No receiver found: ${getElementTextWithContext()}")
@Nullable val selectorExpression: KtExpression?
KtExpression getSelectorExpression(); get() = getExpression(true)
@NotNull val operationTokenNode: ASTNode
ASTNode getOperationTokenNode(); get() = node.findChildByType(KtTokens.OPERATIONS)!!
@NotNull val operationSign: KtToken
KtToken getOperationSign(); get() = operationTokenNode.elementType as KtToken
private fun KtQualifiedExpression.getExpression(afterOperation: Boolean): KtExpression? {
return operationTokenNode.psi?.siblings(afterOperation, false)?.firstIsInstanceOrNull<KtExpression>()
}
} }
compiler/frontend/src/org/jetbrains/kotlin/psi/KtQualifiedExpressionImpl.kt
-46
View File
@@ -1,46 +0,0 @@
/*
* 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.lang.ASTNode
import org.jetbrains.kotlin.lexer.KtToken
import org.jetbrains.kotlin.lexer.KtTokens
import com.intellij.psi.util.PsiTreeUtil
import org.jetbrains.kotlin.psi.psiUtil.*
object KtQualifiedExpressionImpl {
fun KtQualifiedExpression.getOperationTokenNode(): ASTNode {
val operationNode = this.node!!.findChildByType(KtTokens.OPERATIONS)
return operationNode!!
}
fun KtQualifiedExpression.getOperationSign(): KtToken {
return this.operationTokenNode.elementType as KtToken
}
private fun KtQualifiedExpression.getExpression(afterOperation: Boolean): KtExpression? {
return operationTokenNode.psi?.siblings(afterOperation, false)?.firstOrNull { it is KtExpression } as? KtExpression
}
fun KtQualifiedExpression.getReceiverExpression(): KtExpression {
return getExpression(false) ?: throw AssertionError("No receiver found: ${getElementTextWithContext()}")
}
fun KtQualifiedExpression.getSelectorExpression(): KtExpression? {
return getExpression(true)
}
}
compiler/frontend/src/org/jetbrains/kotlin/psi/KtSafeQualifiedExpression.kt
+5 -37
View File
@@ -14,44 +14,12 @@
* limitations under the License. * limitations under the License.
*/ */
package org.jetbrains.kotlin.psi; package org.jetbrains.kotlin.psi
import com.intellij.lang.ASTNode; import com.intellij.lang.ASTNode
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.lexer.KtToken;
public class KtSafeQualifiedExpression extends KtExpressionImpl implements KtQualifiedExpression { class KtSafeQualifiedExpression(node: ASTNode) : KtExpressionImpl(node), KtQualifiedExpression {
public KtSafeQualifiedExpression(@NotNull ASTNode node) { override fun <R, D> accept(visitor: KtVisitor<R, D>, data: D): R {
super(node); return visitor.visitSafeQualifiedExpression(this, data)
}
@Override
public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
return visitor.visitSafeQualifiedExpression(this, data);
}
@NotNull
@Override
public KtExpression getReceiverExpression() {
return KtQualifiedExpressionImpl.INSTANCE.getReceiverExpression(this);
}
@Nullable
@Override
public KtExpression getSelectorExpression() {
return KtQualifiedExpressionImpl.INSTANCE.getSelectorExpression(this);
}
@NotNull
@Override
public ASTNode getOperationTokenNode() {
return KtQualifiedExpressionImpl.INSTANCE.getOperationTokenNode(this);
}
@NotNull
@Override
public KtToken getOperationSign() {
return KtQualifiedExpressionImpl.INSTANCE.getOperationSign(this);
} }
} }
compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/ktPsiUtil.kt
+2 -4
View File
@@ -24,7 +24,6 @@ import com.intellij.psi.PsiParameterList
import com.intellij.psi.PsiWhiteSpace import com.intellij.psi.PsiWhiteSpace
import com.intellij.psi.stubs.StubElement import com.intellij.psi.stubs.StubElement
import com.intellij.psi.tree.TokenSet import com.intellij.psi.tree.TokenSet
import com.intellij.psi.util.PsiTreeUtil
import org.jetbrains.kotlin.KtNodeTypes import org.jetbrains.kotlin.KtNodeTypes
import org.jetbrains.kotlin.diagnostics.DiagnosticSink import org.jetbrains.kotlin.diagnostics.DiagnosticSink
import org.jetbrains.kotlin.diagnostics.Errors import org.jetbrains.kotlin.diagnostics.Errors
@@ -38,7 +37,6 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
import org.jetbrains.kotlin.resolve.calls.model.ArgumentMatch import org.jetbrains.kotlin.resolve.calls.model.ArgumentMatch
import org.jetbrains.kotlin.types.expressions.OperatorConventions import org.jetbrains.kotlin.types.expressions.OperatorConventions
import java.util.* import java.util.*
import kotlin.text.Regex
// NOTE: in this file we collect only Kotlin-specific methods working with PSI and not modifying it // NOTE: in this file we collect only Kotlin-specific methods working with PSI and not modifying it
@@ -148,7 +146,7 @@ fun KtExpression.getQualifiedExpressionForReceiverOrThis(): KtExpression {
} }
fun KtExpression.isDotReceiver(): Boolean = fun KtExpression.isDotReceiver(): Boolean =
(parent as? KtDotQualifiedExpression)?.getReceiverExpression() == this (parent as? KtDotQualifiedExpression)?.receiverExpression == this
// ---------- Block expression ------------------------------------------------------------------------------------------------------------- // ---------- Block expression -------------------------------------------------------------------------------------------------------------
@@ -209,7 +207,7 @@ fun StubBasedPsiElementBase<out KotlinClassOrObjectStub<out KtClassOrObject>>.ge
if (directive != null) { if (directive != null) {
var reference = directive.getImportedReference() var reference = directive.getImportedReference()
while (reference is KtDotQualifiedExpression) { while (reference is KtDotQualifiedExpression) {
reference = reference.getSelectorExpression() reference = reference.selectorExpression
} }
if (reference is KtSimpleNameExpression) { if (reference is KtSimpleNameExpression) {
result.add(reference.getReferencedName()) result.add(reference.getReferencedName())