FIR: implement named arguments #KT-24081 Fixed

2019-03-14 17:21:34 +03:00
parent d65b30dd82
commit 909a5fd32d
12 changed files with 105 additions and 5 deletions
@@ -88,8 +88,7 @@ class FirAnnotationTypeQualifierResolver(private val session: FirSession, privat
                .annotations.find { it.resolvedFqName == TYPE_QUALIFIER_DEFAULT_FQNAME }!!
                .arguments
                .flatMap { argument ->
-                    // TODO: replace after implementation of KT-24081
-                    if (true /*parameter == JvmAnnotationNames.DEFAULT_ANNOTATION_MEMBER_NAME*/)
+                    if (argument !is FirNamedArgumentExpression || argument.name == JvmAnnotationNames.DEFAULT_ANNOTATION_MEMBER_NAME)
                        argument.mapConstantToQualifierApplicabilityTypes()
                    else
                        emptyList()
@@ -191,8 +191,9 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {

        private fun ValueArgument?.toFirExpression(): FirExpression {
            this ?: return FirErrorExpressionImpl(session, this as? KtElement, "No argument given")
+            val name = this.getArgumentName()?.asName
            val expression = this.getArgumentExpression()
-            return when (expression) {
+            val firExpression = when (expression) {
                is KtConstantExpression, is KtStringTemplateExpression -> {
                    expression.accept(this@Visitor, Unit) as FirExpression
                }
@@ -201,6 +202,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
                    { expression }.toFirExpression("Argument is absent")
                }
            }
+            return if (name != null) FirNamedArgumentExpressionImpl(session, expression, name, firExpression) else firExpression
        }

        private fun KtPropertyAccessor?.toFirPropertyAccessor(
@@ -1262,7 +1264,7 @@ class RawFirBuilder(val session: FirSession, val stubMode: Boolean) {
                this.calleeReference = calleeReference
                firFunctionCalls += this
                for (argument in expression.valueArguments) {
-                    arguments += argument.getArgumentExpression().toFirExpression("No argument expression")
+                    arguments += argument.toFirExpression()
                }
                for (typeArgument in expression.typeArguments) {
                    typeArguments += typeArgument.convert<FirTypeProjection>()
@@ -0,0 +1,9 @@
+fun foo(first: String = "", second: Boolean = true, third: Double = 3.1415) {}
+
+fun test() {
+    foo()
+    foo("Alpha", false, 2.71)
+    foo(first = "Hello", second = true)
+    foo(third = -1.0, first = "123")
+    foo(= "")
+}
@@ -0,0 +1,10 @@
+FILE: namedArgument.kt
+    public? final? function foo(first: String = String(), second: Boolean = Boolean(true), third: Double = Double(3.1415)): kotlin/Unit {
+    }
+    public? final? function test(): kotlin/Unit {
+        foo#()
+        foo#(String(Alpha), Boolean(false), Double(2.71))
+        foo#(first = String(Hello), second = Boolean(true))
+        foo#(third = unaryMinus#(Double(1.0)), first = String(123))
+        foo#(ERROR_EXPR(Argument is absent))
+    }
@@ -224,6 +224,11 @@ public class RawFirBuilderTestCaseGenerated extends AbstractRawFirBuilderTestCas
            runTest("compiler/fir/psi2fir/testData/rawBuilder/expressions/modifications.kt");
        }

+        @TestMetadata("namedArgument.kt")
+        public void testNamedArgument() throws Exception {
+            runTest("compiler/fir/psi2fir/testData/rawBuilder/expressions/namedArgument.kt");
+        }
+
        @TestMetadata("nullability.kt")
        public void testNullability() throws Exception {
            runTest("compiler/fir/psi2fir/testData/rawBuilder/expressions/nullability.kt");
@@ -232,7 +232,6 @@ class RawFirBuilderTotalKotlinTestCase : AbstractRawFirBuilderTestCase() {
                        it is KtValueArgumentList || it is KtParameterList || it is KtTypeParameterList || it is KtTypeArgumentList ||
                        it is KtTypeReference && it.parent.parent.parent is KtCallExpression ||
                        it is KtSuperTypeList || it is KtSuperTypeListEntry ||
-                        // TODO: may be we should look at argument after KT-24081
                        it is KtValueArgument || it is KtLambdaArgument || it is KtValueArgumentName ||
                        it is KtContainerNodeForControlStructureBody || it is KtContainerNode ||
                        it is KtStringTemplateEntry ||
@@ -551,6 +551,12 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
        print("${constExpression.kind}(${constExpression.value})")
    }

+    override fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression) {
+        print(namedArgumentExpression.name)
+        print(" = ")
+        namedArgumentExpression.expression.accept(this)
+    }
+
    override fun visitCall(call: FirCall) {
        print("(")
        call.arguments.renderSeparated()
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.expressions
+
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+import org.jetbrains.kotlin.name.Name
+
+interface FirNamedArgumentExpression : FirExpression {
+    val name: Name
+
+    val expression: FirExpression
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitNamedArgumentExpression(this, data)
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        expression.accept(visitor, data)
+        super.acceptChildren(visitor, data)
+    }
+}
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.expressions.impl
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.FirNamedArgumentExpression
+import org.jetbrains.kotlin.fir.transformSingle
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+import org.jetbrains.kotlin.name.Name
+
+class FirNamedArgumentExpressionImpl(
+    session: FirSession,
+    psi: PsiElement?,
+    override val name: Name,
+    override var expression: FirExpression
+) : FirNamedArgumentExpression, FirAbstractExpression(session, psi) {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        expression = expression.transformSingle(transformer, data)
+        return super<FirAbstractExpression>.transformChildren(transformer, data)
+    }
+}
@@ -256,6 +256,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
        return transformJump(returnExpression, data)
    }

+    open fun transformNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): CompositeTransformResult<FirStatement> {
+        return transformExpression(namedArgumentExpression, data)
+    }
+
    open fun transformThrowExpression(throwExpression: FirThrowExpression, data: D): CompositeTransformResult<FirStatement> {
        return transformExpression(throwExpression, data)
    }
@@ -564,6 +568,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
        return transformModifiableQualifiedAccess(modifiableQualifiedAccess, data)
    }

+    final override fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): CompositeTransformResult<FirElement> {
+        return transformNamedArgumentExpression(namedArgumentExpression, data)
+    }
+
    final override fun visitNamedDeclaration(namedDeclaration: FirNamedDeclaration, data: D): CompositeTransformResult<FirElement> {
        return transformNamedDeclaration(namedDeclaration, data)
    }
@@ -256,6 +256,10 @@ abstract class FirVisitor<out R, in D> {
        return visitJump(returnExpression, data)
    }

+    open fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: D): R {
+        return visitExpression(namedArgumentExpression, data)
+    }
+
    open fun visitThrowExpression(throwExpression: FirThrowExpression, data: D): R {
        return visitExpression(throwExpression, data)
    }
@@ -256,6 +256,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
        visitJump(returnExpression, null)
    }

+    open fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression) {
+        visitExpression(namedArgumentExpression, null)
+    }
+
    open fun visitThrowExpression(throwExpression: FirThrowExpression) {
        visitExpression(throwExpression, null)
    }
@@ -564,6 +568,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
        visitModifiableQualifiedAccess(modifiableQualifiedAccess)
    }

+    final override fun visitNamedArgumentExpression(namedArgumentExpression: FirNamedArgumentExpression, data: Nothing?) {
+        visitNamedArgumentExpression(namedArgumentExpression)
+    }
+
    final override fun visitNamedDeclaration(namedDeclaration: FirNamedDeclaration, data: Nothing?) {
        visitNamedDeclaration(namedDeclaration)
    }