lucene/gradle/validation/ecj-lint.gradle

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */

// This adds 'ecjLint' task.

configure(rootProject) {
  configurations {
    ecjDeps
  }

  dependencies {
    ecjDeps "org.eclipse.jdt:ecj:${scriptDepVersions['ecj']}"
  }
}

def resources = scriptResources(buildscript)

allprojects {
  plugins.withType(JavaPlugin) {
    // Create a [sourceSetName]EcjLint task for each source set
    // with a non-empty java.srcDirs. These tasks are then
    // attached to project's "ecjLint" task.
    def lintTasks = sourceSets.collect { sourceSet ->
      def srcDirs = sourceSet.java.sourceDirectories
          .filter { dir -> dir.exists() }

      tasks.create(sourceSet.getTaskName("ecjLint", null), JavaExec, {JavaExec task ->
        // This dependency is on a configuration; technically it causes
        // all dependencies to be resolved before this task executes
        // (this includes scheduling tasks that compile the
        // sources from other projects for example).
        dependsOn sourceSet.compileClasspath

        // The inputs are all source files from the sourceSet.
        inputs.files sourceSet.allSource.asFileTree

        // We create a task for all source sets but ignore those
        // that don't have any Java source directories.
        enabled = !srcDirs.isEmpty()

        classpath = rootProject.configurations.ecjDeps
        mainClass = "org.eclipse.jdt.internal.compiler.batch.Main"

        // Don't emit any .class files.
        // Hack around "-d none" still emitting package-info.class
        // by running in a temporary directory.
        def tmpDst = getTemporaryDir()
        workingDir tmpDst

        // Place input files in an external file to dodge command line argument
        // limits. We could pass a directory but ecj seems to be buggy: when it
        // encounters a module-info.java file it no longer compiles other source files.
        def inputsFile = file("${tmpDst}/ecj-inputs.txt")
        inputsFile.setText(
            srcDirs.collectMany { dir ->
              project.fileTree(dir: dir, include: "**/*.java" ).files
            }
            .collect {file -> file.absolutePath.toString()}.join("\n"), "UTF-8")

        args += [ "-d", "none" ]

        // Compilation environment.
        // we use -source/-target as it is significantly faster than --release
        args += [ "-source", project.java.sourceCompatibility ]
        args += [ "-target", project.java.targetCompatibility ]
        args += [ "-encoding", "UTF-8"]
        args += [ "-proc:none" ]
        args += [ "-nowarn" ]
        args += [ "-enableJavadoc" ]
        args += [ "-properties", file("${resources}/ecj.javadocs.prefs").absolutePath ]

        // We depend on modular paths.
        def modularPaths = sourceSet.modularPaths
        dependsOn modularPaths.compileModulePathConfiguration

        task.argumentProviders.add((CommandLineArgumentProvider) {
          // Add modular dependencies and their transitive dependencies to module path.
          def modularPathFiles = modularPaths.compileModulePathConfiguration.files
          def extraArgs = []
          if (!modularPathFiles.isEmpty()) {
            if (!modularPaths.hasModuleDescriptor()) {
              // We're compiling a non-module so we'll bring everything on module path in
              // otherwise things wouldn't be part of the resolved module graph.
              extraArgs += ["--add-modules", "ALL-MODULE-PATH"]
            }

            extraArgs += ["--module-path", modularPathFiles.join(File.pathSeparator)]
          }

          // Add classpath locations in a lazy provider (can't resolve the
          // configuration at evaluation time). Filter out non-existing entries
          // (output folders for non-existing input source dirs like resources).
          def cpath = sourceSet.compileClasspath.filter { p -> p.exists() }
          cpath = cpath - modularPathFiles
          if (!cpath.isEmpty()) {
            extraArgs += ["-classpath", cpath.join(File.pathSeparator)]
          }

          // Add source location(s) in an external file to avoid command line argument limits.
          extraArgs += ["@" + inputsFile.absolutePath]

          return extraArgs
        })

        doFirst {
          tmpDst.mkdirs()
        }
      })
    }

    task ecjLint() {
      description "Lint Java sources using ECJ."
      group "Verification"

      dependsOn lintTasks
    }

    // Attach ecjLint to check.
    check.dependsOn ecjLint
  }
}