[tool] Change gradle-check logic to enforce alignment of java versions and a minimum (17)

script/tool/lib/src/gradle_check_command.dart

@@ -27,6 +27,8 @@ class GradleCheckCommand extends PackageLoopingCommand {
     super.gitDir,
   });
 
+  static const int _minimumJavaVersion = 17;
+
   @override
   final String name = 'gradle-check';
 
@@ -124,12 +126,18 @@ class GradleCheckCommand extends PackageLoopingCommand {
     // This is tracked as a variable rather than a sequence of &&s so that all
     // failures are reported at once, not just the first one.
     bool succeeded = true;
+    if (!_validateJavaKotlinCompileOptionsAlignment(lines)) {
+      succeeded = false;
+    }
     if (!_validateNamespace(package, contents, isExample: false)) {
       succeeded = false;
     }
     if (!_validateCompatibilityVersions(lines)) {
       succeeded = false;
     }
+    if (!_validateKotlinJvmCompatibility(lines)) {
+      succeeded = false;
+    }
     if (!_validateGradleDrivenLintConfig(package, lines)) {
       succeeded = false;
     }
@@ -356,21 +364,18 @@ build.gradle "namespace" must match the "package" attribute in AndroidManifest.x
   /// than using whatever the client's local toolchaing defaults to (which can
   /// lead to compile errors that show up for clients, but not in CI).
   bool _validateCompatibilityVersions(List<String> gradleLines) {
-    const String requiredJavaVersion = '17';
     final bool hasLanguageVersion = gradleLines.any((String line) =>
         line.contains('languageVersion') && !_isCommented(line));
     final bool hasCompabilityVersions = gradleLines.any((String line) =>
-            line.contains(
-                'sourceCompatibility = JavaVersion.VERSION_$requiredJavaVersion') &&
+            line.contains('sourceCompatibility = JavaVersion.VERSION_') &&
             !_isCommented(line)) &&
         // Newer toolchains default targetCompatibility to the same value as
         // sourceCompatibility, but older toolchains require it to be set
         // explicitly. The exact version cutoff (and of which piece of the
         // toolchain; likely AGP) is unknown; for context see
         // https://github.com/flutter/flutter/issues/125482
         gradleLines.any((String line) =>
-            line.contains(
-                'targetCompatibility = JavaVersion.VERSION_$requiredJavaVersion') &&
+            line.contains('targetCompatibility = JavaVersion.VERSION_') &&
             !_isCommented(line));
     if (!hasLanguageVersion && !hasCompabilityVersions) {
       const String javaErrorMessage = '''
@@ -379,15 +384,15 @@ build.gradle(.kts) must set an explicit Java compatibility version.
 This can be done either via "sourceCompatibility"/"targetCompatibility":
     android {
         compileOptions {
-            sourceCompatibility = JavaVersion.VERSION_$requiredJavaVersion
-            targetCompatibility = JavaVersion.VERSION_$requiredJavaVersion
+            sourceCompatibility = JavaVersion.VERSION_$_minimumJavaVersion
+            targetCompatibility = JavaVersion.VERSION_$_minimumJavaVersion
         }
     }
 
 or "toolchain":
     java {
         toolchain {
-            languageVersion = JavaLanguageVersion.of($requiredJavaVersion)
+            languageVersion = JavaLanguageVersion.of($_minimumJavaVersion)
         }
     }
 
@@ -399,11 +404,16 @@ for more details.''';
           '$indentation${javaErrorMessage.split('\n').join('\n$indentation')}');
       return false;
     }
+
+    return true;
+  }
+
+  bool _validateKotlinJvmCompatibility(List<String> gradleLines) {
     bool isKotlinOptions(String line) =>
         line.contains('kotlinOptions') && !_isCommented(line);
     final bool hasKotlinOptions = gradleLines.any(isKotlinOptions);
     final bool kotlinOptionsUsesJavaVersion = gradleLines.any((String line) =>
-        line.contains('jvmTarget = JavaVersion.VERSION_$requiredJavaVersion') &&
+        line.contains('jvmTarget = JavaVersion.VERSION_') &&
         !_isCommented(line));
     // Either does not set kotlinOptions or does and uses non-string based syntax.
     if (hasKotlinOptions && !kotlinOptionsUsesJavaVersion) {
@@ -421,7 +431,7 @@ If build.gradle(.kts) sets jvmTarget then it must use JavaVersion syntax.
   Good:
     android {
       kotlinOptions {
-          jvmTarget = JavaVersion.VERSION_$requiredJavaVersion.toString()
+          jvmTarget = JavaVersion.VERSION_$_minimumJavaVersion.toString()
       }
     }
   BAD:
@@ -431,6 +441,45 @@ If build.gradle(.kts) sets jvmTarget then it must use JavaVersion syntax.
           '$indentation${kotlinErrorMessage.split('\n').join('\n$indentation')}');
       return false;
     }
+    // No error condition.
+    return true;
+  }
+
+  bool _validateJavaKotlinCompileOptionsAlignment(List<String> gradleLines) {
+    final List<String> javaVersions = <String>[];
+    // Some java versions have the format VERSION_1_8 but we dont need to handle those
+    // because they are below the minimum.
+    final RegExp javaVersionMatcher =
+        RegExp(r'JavaVersion.VERSION_(?<javaVersion>\d+)');
+    for (final String line in gradleLines) {
+      final RegExpMatch? match = javaVersionMatcher.firstMatch(line);
+      if (!_isCommented(line) && match != null) {
+        final String? foundVersion = match.namedGroup('javaVersion');
+        if (foundVersion != null) {
+          javaVersions.add(foundVersion);
+        }
+      }
+    }
+    if (javaVersions.isNotEmpty) {
+      final int version = int.parse(javaVersions.first);
+      if (version < _minimumJavaVersion) {
+        final String minimumJavaVersionError = '''
+build.gradle(.kts) uses "JavaVersion.VERSION_$version".
+Which is below the minimum required. Use at least "JavaVersion.VERSION_$_minimumJavaVersion".
+''';
+        printError(
+            '$indentation${minimumJavaVersionError.split('\n').join('\n$indentation')}');
+        return false;
+      }
+      if (!javaVersions.every((String element) => element == '$version')) {
+        const String javaVersionAlignmentError = '''
+If build.gradle(.kts) uses JavaVersion.* versions must be the same.
+''';
+        printError(
+            '$indentation${javaVersionAlignmentError.split('\n').join('\n$indentation')}');
+        return false;
+      }
+    }
 
     return true;
   }

script/tool/test/gradle_check_command_test.dart

@@ -50,7 +50,9 @@ void main() {
     String compileSdk = '36',
     bool includeKotlinOptions = true,
     bool commentKotlinOptions = false,
-    bool useDeprecatedJvmTarget = false,
+    bool useDeprecatedJvmTargetStyle = false,
+    int jvmTargetValue = 17,
+    int kotlinJvmValue = 17,
   }) {
     final File buildGradle = package
         .platformDirectory(FlutterPlatform.android)
@@ -74,16 +76,17 @@ java {
 
 ''';
     final String sourceCompat =
-        '${commentSourceLanguage ? '// ' : ''}sourceCompatibility = JavaVersion.VERSION_17';
+        '${commentSourceLanguage ? '// ' : ''}sourceCompatibility = JavaVersion.VERSION_$jvmTargetValue';
     final String targetCompat =
-        '${commentSourceLanguage ? '// ' : ''}targetCompatibility = JavaVersion.VERSION_17';
+        '${commentSourceLanguage ? '// ' : ''}targetCompatibility = JavaVersion.VERSION_$jvmTargetValue';
     final String namespace =
         "    ${commentNamespace ? '// ' : ''}namespace = '$_defaultFakeNamespace'";
-    final String jvmTarget =
-        useDeprecatedJvmTarget ? '17' : 'JavaVersion.VERSION_17.toString()';
+    final String kotlinJvmTarget = useDeprecatedJvmTargetStyle
+        ? '$jvmTargetValue'
+        : 'JavaVersion.VERSION_$kotlinJvmValue.toString()';
     final String kotlinConfig = '''
     ${commentKotlinOptions ? '//' : ''}kotlinOptions {
-        ${commentKotlinOptions ? '//' : ''}jvmTarget = $jvmTarget
+        ${commentKotlinOptions ? '//' : ''}jvmTarget = $kotlinJvmTarget
     ${commentKotlinOptions ? '//' : ''}}''';
 
     buildGradle.writeAsStringSync('''
@@ -391,6 +394,84 @@ dependencies {
     );
   });
 
+  test('fails when sourceCompatibility/targetCompatibility are below minimum',
+      () async {
+    final RepositoryPackage package =
+        createFakePlugin('a_plugin', packagesDir, examples: <String>[]);
+    writeFakePluginBuildGradle(package,
+        includeSourceCompat: true,
+        includeTargetCompat: true,
+        jvmTargetValue: 11);
+    writeFakeManifest(package);
+
+    Error? commandError;
+    final List<String> output = await runCapturingPrint(
+        runner, <String>['gradle-check'], errorHandler: (Error e) {
+      commandError = e;
+    });
+
+    expect(commandError, isA<ToolExit>());
+    expect(
+      output,
+      containsAllInOrder(<Matcher>[
+        contains(
+            'Which is below the minimum required. Use at least "JavaVersion.VERSION_'),
+      ]),
+    );
+  });
+
+  test('fails when compatibility values do not match kotlinOptions', () async {
+    final RepositoryPackage package =
+        createFakePlugin('a_plugin', packagesDir, examples: <String>[]);
+    writeFakePluginBuildGradle(
+      package,
+      includeSourceCompat: true,
+      includeTargetCompat: true,
+      jvmTargetValue: 21,
+      // ignore: avoid_redundant_argument_values
+      kotlinJvmValue: 17,
+    );
+    writeFakeManifest(package);
+
+    Error? commandError;
+    final List<String> output = await runCapturingPrint(
+        runner, <String>['gradle-check'], errorHandler: (Error e) {
+      commandError = e;
+    });
+
+    expect(commandError, isA<ToolExit>());
+    expect(
+      output,
+      containsAllInOrder(<Matcher>[
+        contains(
+            'If build.gradle(.kts) uses JavaVersion.* versions must be the same.'),
+      ]),
+    );
+  });
+
+  test('passes when jvmValues are higher than minimim', () async {
+    final RepositoryPackage package =
+        createFakePlugin('a_plugin', packagesDir, examples: <String>[]);
+    writeFakePluginBuildGradle(
+      package,
+      includeSourceCompat: true,
+      includeTargetCompat: true,
+      jvmTargetValue: 21,
+      kotlinJvmValue: 21,
+    );
+    writeFakeManifest(package);
+
+    final List<String> output =
+        await runCapturingPrint(runner, <String>['gradle-check']);
+
+    expect(
+      output,
+      containsAllInOrder(<Matcher>[
+        contains('Validating android/build.gradle'),
+      ]),
+    );
+  });
+
   test('passes when sourceCompatibility and targetCompatibility are specified',
       () async {
     final RepositoryPackage package =
@@ -1242,7 +1323,7 @@ dependencies {
       writeFakePluginBuildGradle(
         package,
         includeLanguageVersion: true,
-        useDeprecatedJvmTarget: true,
+        useDeprecatedJvmTargetStyle: true,
       );
       writeFakeManifest(package);