Support trailing comma

^KT-34743 Fixed

compiler/frontend/src/org/jetbrains/kotlin/resolve/PlatformConfiguratorBase.kt

@@ -32,11 +32,12 @@ private val DEFAULT_DECLARATION_CHECKERS = listOf(
     ReservedMembersAndConstructsForInlineClass(),
     ResultClassInReturnTypeChecker(),
     LocalVariableTypeParametersChecker(),
-    TailrecFunctionChecker
+    TailrecFunctionChecker,
+    TrailingCommaDeclarationChecker
 )
 
 private val DEFAULT_CALL_CHECKERS = listOf(
-    CapturingInClosureChecker(), InlineCheckerWrapper(), SafeCallChecker(),
+    CapturingInClosureChecker(), InlineCheckerWrapper(), SafeCallChecker(), TrailingCommaCallChecker,
     DeprecatedCallChecker, CallReturnsArrayOfNothingChecker(), InfixCallChecker(), OperatorCallChecker(),
     ConstructorHeaderCallChecker, ProtectedConstructorCallChecker, ApiVersionCallChecker,
     CoroutineSuspendCallChecker, BuilderFunctionsCallChecker, DslScopeViolationCallChecker, MissingDependencyClassChecker,

compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt

@@ -43,6 +43,7 @@ import org.jetbrains.kotlin.resolve.PossiblyBareType.type
 import org.jetbrains.kotlin.resolve.bindingContextUtil.recordScope
 import org.jetbrains.kotlin.resolve.calls.checkers.checkCoroutinesFeature
 import org.jetbrains.kotlin.resolve.calls.tasks.DynamicCallableDescriptors
+import org.jetbrains.kotlin.resolve.checkers.TrailingCommaChecker
 import org.jetbrains.kotlin.resolve.descriptorUtil.findImplicitOuterClassArguments
 import org.jetbrains.kotlin.resolve.scopes.LazyScopeAdapter
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope
@@ -289,6 +290,8 @@ class TypeResolver(
                 val returnType = if (returnTypeRef != null) resolveType(c.noBareTypes(), returnTypeRef)
                 else moduleDescriptor.builtIns.unitType
 
+                TrailingCommaChecker.check(type.parameterList?.trailingComma, c.trace, languageVersionSettings)
+
                 result = type(
                     createFunctionType(
                         moduleDescriptor.builtIns, annotations, receiverType,
@@ -449,6 +452,10 @@ class TypeResolver(
     ): PossiblyBareType {
         val qualifierParts = qualifierResolutionResult.qualifierParts
 
+        if (element is KtUserType) {
+            TrailingCommaChecker.check(element.typeArgumentList?.trailingComma, c.trace, languageVersionSettings)
+        }
+
         return when (descriptor) {
             is TypeParameterDescriptor -> {
                 assert(qualifierParts.size == 1) {

compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/TrailingCommaChecker.kt

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * 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.resolve.checkers
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.diagnostics.Errors
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.calls.checkers.AdditionalTypeChecker
+import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker
+import org.jetbrains.kotlin.resolve.calls.checkers.CallCheckerContext
+import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+import org.jetbrains.kotlin.types.KotlinType
+
+// TODO: remove these checkers before 1.4 is released
+
+object TrailingCommaChecker {
+    fun check(trailingComma: PsiElement?, trace: BindingTrace, languageVersionSettings: LanguageVersionSettings) {
+        if (!languageVersionSettings.supportsFeature(LanguageFeature.TrailingCommas) && trailingComma != null) {
+            trace.report(Errors.UNSUPPORTED_FEATURE.on(trailingComma, LanguageFeature.TrailingCommas to languageVersionSettings))
+        }
+    }
+}
+
+object TrailingCommaDeclarationChecker : DeclarationChecker {
+    override fun check(declaration: KtDeclaration, descriptor: DeclarationDescriptor, context: DeclarationCheckerContext) {
+        when (declaration) {
+            is KtClass -> {
+                TrailingCommaChecker.check(declaration.typeParameterList?.trailingComma, context.trace, context.languageVersionSettings)
+            }
+            is KtCallableDeclaration -> { // also it's executed for anonymous function declarations
+                TrailingCommaChecker.check(declaration.valueParameterList?.trailingComma, context.trace, context.languageVersionSettings)
+                TrailingCommaChecker.check(declaration.typeParameterList?.trailingComma, context.trace, context.languageVersionSettings)
+                if (declaration is KtProperty && declaration.setter != null) {
+                    TrailingCommaChecker.check(
+                        declaration.setter?.parameterList?.trailingComma,
+                        context.trace,
+                        context.languageVersionSettings
+                    )
+                }
+            }
+            is KtDestructuringDeclaration -> {
+                TrailingCommaChecker.check(declaration.trailingComma, context.trace, context.languageVersionSettings)
+            }
+            is KtTypeAlias -> {
+                TrailingCommaChecker.check(declaration.typeParameterList?.trailingComma, context.trace, context.languageVersionSettings)
+            }
+        }
+    }
+}
+
+object TrailingCommaCallChecker : CallChecker {
+    override fun check(resolvedCall: ResolvedCall<*>, reportOn: PsiElement, context: CallCheckerContext) {
+        when (val callElement = resolvedCall.call.callElement) {
+            is KtArrayAccessExpression -> TrailingCommaChecker.check(
+                callElement.trailingComma,
+                context.trace,
+                context.languageVersionSettings
+            )
+            is KtCollectionLiteralExpression -> TrailingCommaChecker.check(
+                callElement.trailingComma,
+                context.trace,
+                context.languageVersionSettings
+            )
+            is KtWhenExpression -> {
+                if (callElement.subjectExpression != null) {
+                    callElement.entries.forEach { whenEntry ->
+                        TrailingCommaChecker.check(whenEntry.trailingComma, context.trace, context.languageVersionSettings)
+                    }
+                }
+            }
+            else -> {
+                resolvedCall.call.run {
+                    TrailingCommaChecker.check(valueArgumentList?.trailingComma, context.trace, context.languageVersionSettings)
+                }
+            }
+        }
+    }
+}

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java

@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValue;
 import org.jetbrains.kotlin.resolve.calls.tower.KotlinResolutionCallbacksImpl;
 import org.jetbrains.kotlin.resolve.calls.tower.LambdaContextInfo;
+import org.jetbrains.kotlin.resolve.checkers.TrailingCommaChecker;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 import org.jetbrains.kotlin.resolve.inline.InlineUtil;
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope;
@@ -490,6 +491,13 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor {
 
     @Override
     public KotlinTypeInfo visitTryExpression(@NotNull KtTryExpression expression, ExpressionTypingContext typingContext) {
+        expression.getCatchClauses().forEach((catchClause) -> {
+            KtParameterList parameters = catchClause.getParameterList();
+            if (parameters != null) {
+                TrailingCommaChecker.INSTANCE.check(parameters.getTrailingComma(), typingContext.trace, typingContext.languageVersionSettings);
+            }
+        });
+
         if (typingContext.languageVersionSettings.supportsFeature(LanguageFeature.NewInference)) {
             return resolveTryExpressionWithNewInference(expression, typingContext);
         }

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DestructuringDeclarationResolver.kt

@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.resolve.DataClassDescriptorResolver
 import org.jetbrains.kotlin.resolve.LocalVariableResolver
 import org.jetbrains.kotlin.resolve.TypeResolver
 import org.jetbrains.kotlin.resolve.calls.context.ContextDependency
+import org.jetbrains.kotlin.resolve.checkers.TrailingCommaChecker
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope
 import org.jetbrains.kotlin.resolve.scopes.LexicalWritableScope
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
@@ -56,6 +57,8 @@ class DestructuringDeclarationResolver(
             result.add(variableDescriptor)
         }
 
+        TrailingCommaChecker.check(destructuringDeclaration.trailingComma, context.trace, context.languageVersionSettings)
+
         return result
     }
 

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt

@@ -25,6 +25,8 @@ import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.BindingContext.EXPECTED_RETURN_TYPE
 import org.jetbrains.kotlin.resolve.calls.context.ContextDependency
 import org.jetbrains.kotlin.resolve.calls.inference.model.TypeVariableTypeConstructor
+import org.jetbrains.kotlin.resolve.checkers.TrailingCommaChecker
+import org.jetbrains.kotlin.resolve.checkers.TrailingCommaDeclarationChecker
 import org.jetbrains.kotlin.resolve.checkers.UnderscoreChecker
 import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil
 import org.jetbrains.kotlin.resolve.scopes.LexicalWritableScope
@@ -141,6 +143,11 @@ internal class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Expre
             components.identifierChecker.checkDeclaration(it, context.trace)
             UnderscoreChecker.checkNamed(it, context.trace, components.languageVersionSettings, allowSingleUnderscore = true)
         }
+        TrailingCommaChecker.check(
+            expression.functionLiteral.valueParameterList?.trailingComma,
+            context.trace,
+            context.languageVersionSettings
+        )
         val safeReturnType = computeReturnType(expression, context, functionDescriptor, functionTypeExpected)
         functionDescriptor.setReturnType(safeReturnType)