Do not report warning if -XXLanguage turns on bugfix

KT-25554 Fixed

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArguments.kt

@@ -245,11 +245,9 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
         }
 
     private fun HashMap<LanguageFeature, LanguageFeature.State>.configureLanguageFeaturesFromInternalArgs(collector: MessageCollector) {
-        val languageSettingsParser = LanguageSettingsParser()
         val featuresThatForcePreReleaseBinaries = mutableListOf<LanguageFeature>()
 
-        for (argument in internalArguments) {
-            val (feature, state) = languageSettingsParser.parseInternalArgument(argument, collector) ?: continue
+        for ((feature, state) in internalArguments.filterIsInstance<ManualLanguageFeatureSetting>()) {
             put(feature, state)
             if (state == LanguageFeature.State.ENABLED && feature.forcesPreReleaseBinariesIfEnabled()) {
                 featuresThatForcePreReleaseBinaries += feature

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonToolArguments.kt

@@ -50,5 +50,5 @@ abstract class CommonToolArguments : Freezable(), Serializable {
     @Argument(value = "-Werror", description = "Report an error if there are any warnings")
     var allWarningsAsErrors: Boolean by FreezableVar(false)
 
-    var internalArguments: List<String> by FreezableVar(emptyList())
+    var internalArguments: List<InternalArgument> by FreezableVar(emptyList())
 }

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/InternalCompilerArgument.kt

@@ -6,8 +6,6 @@
 package org.jetbrains.kotlin.cli.common.arguments
 
 import org.jetbrains.kotlin.cli.common.arguments.InternalArgumentParser.Companion.INTERNAL_ARGUMENT_PREFIX
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
-import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.config.LanguageFeature
 
 /**
@@ -25,7 +23,7 @@ interface InternalArgumentParser<A : InternalArgument> {
     // Should be fast
     fun canParse(arg: String): Boolean
 
-    fun parseInternalArgument(arg: String, messageCollector: MessageCollector): A?
+    fun parseInternalArgument(arg: String, errors: ArgumentParseErrors): A?
 
     companion object {
         internal const val INTERNAL_ARGUMENT_PREFIX = "-XX"
@@ -41,13 +39,13 @@ abstract class AbstractInternalArgumentParser<A : InternalArgument>(familyName:
 
     override fun canParse(arg: String): Boolean = arg.startsWith(wholePrefix)
 
-    override fun parseInternalArgument(arg: String, messageCollector: MessageCollector): A? {
+    override fun parseInternalArgument(arg: String, errors: ArgumentParseErrors): A? {
         if (!arg.startsWith(wholePrefix)) return null
 
-        return parseTail(arg.removePrefix(wholePrefix), arg, messageCollector)
+        return parseTail(arg.removePrefix(wholePrefix), arg, errors)
     }
 
-    abstract fun parseTail(tail: String, wholeArgument: String, messageCollector: MessageCollector): A?
+    abstract fun parseTail(tail: String, wholeArgument: String, errors: ArgumentParseErrors): A?
 }
 
 
@@ -55,9 +53,9 @@ abstract class AbstractInternalArgumentParser<A : InternalArgument>(familyName:
 class LanguageSettingsParser : AbstractInternalArgumentParser<ManualLanguageFeatureSetting>("Language") {
 
     // Expected tail form: ':(+|-)<language feature name>'
-    override fun parseTail(tail: String, wholeArgument: String, messageCollector: MessageCollector): ManualLanguageFeatureSetting? {
+    override fun parseTail(tail: String, wholeArgument: String, errors: ArgumentParseErrors): ManualLanguageFeatureSetting? {
         fun reportAndReturnNull(message: String): Nothing? {
-            messageCollector.report(CompilerMessageSeverity.STRONG_WARNING, message)
+            errors.internalArgumentsParsingProblems += message
             return null
         }
 
@@ -76,12 +74,18 @@ class LanguageSettingsParser : AbstractInternalArgumentParser<ManualLanguageFeat
         if (languageFeatureName.isEmpty()) return reportAndReturnNull("Empty language feature name for internal argument '$wholeArgument'")
 
         val languageFeature = LanguageFeature.fromString(languageFeatureName)
-                ?: return reportAndReturnNull("Unknown language feature '$languageFeatureName' in passed internal argument '$wholeArgument'")
+            ?: return reportAndReturnNull("Unknown language feature '$languageFeatureName' in passed internal argument '$wholeArgument'")
 
-        return ManualLanguageFeatureSetting(languageFeature, languageFeatureState)
+        return ManualLanguageFeatureSetting(languageFeature, languageFeatureState, wholeArgument)
     }
 }
 
-interface InternalArgument
+interface InternalArgument {
+    val stringRepresentation: String
+}
 
-data class ManualLanguageFeatureSetting(val languageFeature: LanguageFeature, val state: LanguageFeature.State) : InternalArgument
+data class ManualLanguageFeatureSetting(
+    val languageFeature: LanguageFeature,
+    val state: LanguageFeature.State,
+    override val stringRepresentation: String
+) : InternalArgument

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/parseCommandLineArguments.kt

@@ -54,7 +54,10 @@ data class ArgumentParseErrors(
 
     var argumentWithoutValue: String? = null,
 
-    val argfileErrors: MutableList<String> = SmartList()
+    val argfileErrors: MutableList<String> = SmartList(),
+
+    // Reports from internal arguments parsers
+    val internalArgumentsParsingProblems: MutableList<String> = SmartList()
 )
 
 // Parses arguments into the passed [result] object. Errors related to the parsing will be collected into [CommonToolArguments.errors].
@@ -108,7 +111,7 @@ private fun <A : CommonToolArguments> parsePreprocessedCommandLineArguments(args
     }
 
     val freeArgs = ArrayList<String>()
-    val internalArguments = ArrayList<String>()
+    val internalArguments = ArrayList<InternalArgument>()
 
     var i = 0
     loop@ while (i < args.size) {
@@ -132,7 +135,7 @@ private fun <A : CommonToolArguments> parsePreprocessedCommandLineArguments(args
             if (parser == null) {
                 errors.unknownExtraFlags += arg
             } else {
-                internalArguments.add(arg)
+                internalArguments.add(parser.parseInternalArgument(arg, errors) ?: continue)
             }
 
             continue