org.gradle.language.base.internal.compile.Compiler Java Examples

public CompilerDaemon getDaemon(File workingDir, final DaemonForkOptions forkOptions) {
    return new CompilerDaemon() {
        public <T extends CompileSpec> CompileResult execute(Compiler<T> compiler, T spec) {
            ClassLoader groovyClassLoader = classLoaderFactory.createIsolatedClassLoader(new DefaultClassPath(forkOptions.getClasspath()));
            FilteringClassLoader filteredGroovy = classLoaderFactory.createFilteringClassLoader(groovyClassLoader);
            for (String packageName : forkOptions.getSharedPackages()) {
                filteredGroovy.allowPackage(packageName);
            }

            ClassLoader workerClassLoader = new MutableURLClassLoader(filteredGroovy, ClasspathUtil.getClasspath(compiler.getClass().getClassLoader()));

            try {
                byte[] serializedWorker = GUtil.serialize(new Worker<T>(compiler, spec));
                ClassLoaderObjectInputStream inputStream = new ClassLoaderObjectInputStream(new ByteArrayInputStream(serializedWorker), workerClassLoader);
                Callable<?> worker = (Callable<?>) inputStream.readObject();
                Object result = worker.call();
                byte[] serializedResult = GUtil.serialize(result);
                inputStream = new ClassLoaderObjectInputStream(new ByteArrayInputStream(serializedResult), getClass().getClassLoader());
                return (CompileResult) inputStream.readObject();
            } catch (Exception e) {
                throw UncheckedException.throwAsUncheckedException(e);
            }
        }
    };
}
 

public <T extends CompileSpec> CompileResult execute(Compiler<T> compiler, T spec) {
    // currently we just allow a single compilation thread at a time (per compiler daemon)
    // one problem to solve when allowing multiple threads is how to deal with memory requirements specified by compile tasks
    try {
        server.execute(compiler, spec);
        return compileResults.take();
    } catch (InterruptedException e) {
        throw UncheckedException.throwAsUncheckedException(e);
    }
}
 

static WorkResult execute(ScalaJavaJointCompileSpec spec) {
    LOGGER.info("Compiling with Zinc Scala compiler.");

    xsbti.Logger logger = new SbtLoggerAdapter();

    com.typesafe.zinc.Compiler compiler = createCompiler(spec.getScalaClasspath(), spec.getZincClasspath(), logger);
    List<String> scalacOptions = new ScalaCompilerArgumentsGenerator().generate(spec);
    List<String> javacOptions = new JavaCompilerArgumentsBuilder(spec).includeClasspath(false).build();
    Inputs inputs = Inputs.create(ImmutableList.copyOf(spec.getClasspath()), ImmutableList.copyOf(spec.getSource()), spec.getDestinationDir(),
            scalacOptions, javacOptions, spec.getScalaCompileOptions().getIncrementalOptions().getAnalysisFile(), spec.getAnalysisMap(), "mixed", getIncOptions(), true);
    if (LOGGER.isDebugEnabled()) {
        Inputs.debug(inputs, logger);
    }

    try {
        compiler.compile(inputs, logger);
    } catch (xsbti.CompileFailed e) {
        throw new CompilationFailedException(e);
    }

    return new SimpleWorkResult(true);
}
 

static com.typesafe.zinc.Compiler createCompiler(Iterable<File> scalaClasspath, Iterable<File> zincClasspath, xsbti.Logger logger) {
    ScalaLocation scalaLocation = ScalaLocation.fromPath(Lists.newArrayList(scalaClasspath));
    SbtJars sbtJars = SbtJars.fromPath(Lists.newArrayList(zincClasspath));
    Setup setup = Setup.create(scalaLocation, sbtJars, Jvm.current().getJavaHome(), true);
    if (LOGGER.isDebugEnabled()) {
        Setup.debug(setup, logger);
    }
    return com.typesafe.zinc.Compiler.getOrCreate(setup, logger);
}
 

@TaskAction
protected void compile(IncrementalTaskInputs inputs) {
    if (!compileOptions.isIncremental()) {
        compile();
        return;
    }

    SingleMessageLogger.incubatingFeatureUsed("Incremental java compilation");

    DefaultJavaCompileSpec spec = createSpec();
    final CacheRepository repository1 = getCacheRepository();
    final JavaCompile javaCompile1 = this;
    final GeneralCompileCaches generalCaches1 = getGeneralCompileCaches();
    CompileCaches compileCaches = new CompileCaches() {
        private final CacheRepository repository = repository1;
        private final JavaCompile javaCompile = javaCompile1;
        private final GeneralCompileCaches generalCaches = generalCaches1;

        public ClassAnalysisCache getClassAnalysisCache() {
            return generalCaches.getClassAnalysisCache();
        }

        public JarSnapshotCache getJarSnapshotCache() {
            return generalCaches.getJarSnapshotCache();
        }

        public LocalJarClasspathSnapshotStore getLocalJarClasspathSnapshotStore() {
            return new LocalJarClasspathSnapshotStore(repository, javaCompile);
        }

        public LocalClassSetAnalysisStore getLocalClassSetAnalysisStore() {
            return new LocalClassSetAnalysisStore(repository, javaCompile);
        }
    };
    IncrementalCompilerFactory factory = new IncrementalCompilerFactory(
            (FileOperations) getProject(), getPath(), createCompiler(spec), source, compileCaches, (IncrementalTaskInputsInternal) inputs);
    Compiler<JavaCompileSpec> compiler = factory.createCompiler();
    performCompilation(spec, compiler);
}
 

private Compiler<ScalaJavaJointCompileSpec> getCompiler(ScalaJavaJointCompileSpec spec) {
    if (compiler == null) {
        ProjectInternal projectInternal = (ProjectInternal) getProject();
        IsolatedAntBuilder antBuilder = getServices().get(IsolatedAntBuilder.class);
        CompilerDaemonFactory compilerDaemonFactory = getServices().get(CompilerDaemonManager.class);
        JavaCompilerFactory javaCompilerFactory = getServices().get(JavaCompilerFactory.class);
        ScalaCompilerFactory scalaCompilerFactory = new ScalaCompilerFactory(projectInternal, antBuilder, javaCompilerFactory, compilerDaemonFactory);
        Compiler<ScalaJavaJointCompileSpec> delegatingCompiler = scalaCompilerFactory.newCompiler(spec);
        compiler = new CleaningScalaCompiler(delegatingCompiler, getOutputs());
    }
    return compiler;
}
 

static WorkResult execute(ScalaJavaJointCompileSpec spec) {
    LOGGER.info("Compiling with Zinc Scala compiler.");

    xsbti.Logger logger = new SbtLoggerAdapter();

    com.typesafe.zinc.Compiler compiler = createCompiler(spec.getScalaClasspath(), spec.getZincClasspath(), logger);
    List<String> scalacOptions = new ScalaCompilerArgumentsGenerator().generate(spec);
    List<String> javacOptions = new JavaCompilerArgumentsBuilder(spec).includeClasspath(false).build();
    Inputs inputs = Inputs.create(ImmutableList.copyOf(spec.getClasspath()), ImmutableList.copyOf(spec.getSource()), spec.getDestinationDir(),
            scalacOptions, javacOptions, spec.getScalaCompileOptions().getIncrementalOptions().getAnalysisFile(), spec.getAnalysisMap(), "mixed", getIncOptions(), true);
    if (LOGGER.isDebugEnabled()) {
        Inputs.debug(inputs, logger);
    }

    try {
        compiler.compile(inputs, logger);
    } catch (xsbti.CompileFailed e) {
        throw new CompilationFailedException(e);
    }

    return new SimpleWorkResult(true);
}
 

private Compiler<ScalaJavaJointCompileSpec> getCompiler(ScalaJavaJointCompileSpec spec) {
    if (compiler == null) {
        ProjectInternal projectInternal = (ProjectInternal) getProject();
        IsolatedAntBuilder antBuilder = getServices().get(IsolatedAntBuilder.class);
        CompilerDaemonFactory compilerDaemonFactory = getServices().get(CompilerDaemonManager.class);
        JavaCompilerFactory javaCompilerFactory = getServices().get(JavaCompilerFactory.class);
        ScalaCompilerFactory scalaCompilerFactory = new ScalaCompilerFactory(projectInternal, antBuilder, javaCompilerFactory, compilerDaemonFactory);
        Compiler<ScalaJavaJointCompileSpec> delegatingCompiler = scalaCompilerFactory.newCompiler(spec);
        compiler = new CleaningScalaCompiler(delegatingCompiler, getOutputs());
    }
    return compiler;
}
 

static com.typesafe.zinc.Compiler createCompiler(Iterable<File> scalaClasspath, Iterable<File> zincClasspath, xsbti.Logger logger) {
    ScalaLocation scalaLocation = ScalaLocation.fromPath(Lists.newArrayList(scalaClasspath));
    SbtJars sbtJars = SbtJars.fromPath(Lists.newArrayList(zincClasspath));
    Setup setup = Setup.create(scalaLocation, sbtJars, Jvm.current().getJavaHome(), true);
    if (LOGGER.isDebugEnabled()) {
        Setup.debug(setup, logger);
    }
    return com.typesafe.zinc.Compiler.getOrCreate(setup, logger);
}
 

private Compiler<JavaCompileSpec> createTargetCompiler(CompileOptions options, boolean jointCompilation) {
    if (options.isFork() && options.getForkOptions().getExecutable() != null) {
        return new CommandLineJavaCompiler();
    }

    Compiler<JavaCompileSpec> compiler = new JdkJavaCompiler();
    if (options.isFork() && !jointCompilation) {
        return new DaemonJavaCompiler(daemonWorkingDir, compiler, compilerDaemonFactory);
    }

    return compiler;
}
 

private void executeExternalJavadoc() {
    JavadocSpec spec = new JavadocSpec();
    spec.setExecutable(executable);
    spec.setOptions(options);
    spec.setIgnoreFailures(!failOnError);
    spec.setWorkingDir(getProject().getProjectDir());
    spec.setOptionsFile(getOptionsFile());

    Compiler<JavadocSpec> generator = ((JavaToolChainInternal) getToolChain()).select(null).newCompiler(spec);
    generator.execute(spec);
}
 

public Compiler<GroovyJavaJointCompileSpec> newCompiler(GroovyJavaJointCompileSpec spec) {
    CompileOptions javaOptions = spec.getCompileOptions();
    GroovyCompileOptions groovyOptions = spec.getGroovyCompileOptions();
    Compiler<JavaCompileSpec> javaCompiler = javaCompilerFactory.createForJointCompilation(javaOptions);
    Compiler<GroovyJavaJointCompileSpec> groovyCompiler = new ApiGroovyCompiler(javaCompiler);
    CompilerDaemonFactory daemonFactory;
    if (groovyOptions.isFork()) {
        daemonFactory = compilerDaemonFactory;
    } else {
        daemonFactory = inProcessCompilerDaemonFactory;
    }
    groovyCompiler = new DaemonGroovyCompiler(project.getRootProject().getProjectDir(), groovyCompiler, project.getServices().get(ClassPathRegistry.class), daemonFactory);
    return new NormalizingGroovyCompiler(groovyCompiler);
}
 

@SuppressWarnings("unchecked")
@Override
public <T extends CompileSpec> Compiler<T> newCompiler(Class<T> spec) {
  if (JavaCompileSpec.class.isAssignableFrom(spec)) {
    return (Compiler<T>) new NormalizingJavaCompiler(new ErrorProneCompiler(configuration));
  }
  throw new IllegalArgumentException(
      String.format("Don't know how to compile using spec of type %s.", spec.getSimpleName()));
}
 

public WorkResult execute(T spec) {
    StaleClassCleaner cleaner = createCleaner(spec);

    cleaner.setDestinationDir(spec.getDestinationDir());
    cleaner.setSource(spec.getSource());
    cleaner.execute();

    Compiler<? super T> compiler = getCompiler();
    return compiler.execute(spec);
}
 

public <T extends CompileSpec> Compiler<T> newCompiler(T spec) {
    if (spec instanceof CppCompileSpec) {
        return castCompiler(createCppCompiler());
    }
    if (spec instanceof CCompileSpec) {
        return castCompiler(createCCompiler());
    }
    if (spec instanceof ObjectiveCppCompileSpec) {
        return castCompiler(createObjectiveCppCompiler());
    }
    if (spec instanceof ObjectiveCCompileSpec) {
        return castCompiler(createObjectiveCCompiler());
    }
    if (spec instanceof WindowsResourceCompileSpec) {
        throw new RuntimeException("Windows resource compiler is not available");
    }
    if (spec instanceof AssembleSpec) {
        return castCompiler(createAssembler());
    }
    if (spec instanceof LinkerSpec) {
        return castCompiler(createLinker());
    }
    if (spec instanceof StaticLibraryArchiverSpec) {
        return castCompiler(createStaticLibraryArchiver());
    }
    throw new IllegalArgumentException(String.format("Don't know how to compile from a spec of type %s.", spec.getClass().getSimpleName()));
}
 

private Compiler<GroovyJavaJointCompileSpec> getCompiler(GroovyJavaJointCompileSpec spec) {
    if (compiler == null) {
        ProjectInternal projectInternal = (ProjectInternal) getProject();
        CompilerDaemonManager compilerDaemonManager = getServices().get(CompilerDaemonManager.class);
        InProcessCompilerDaemonFactory inProcessCompilerDaemonFactory = getServices().get(InProcessCompilerDaemonFactory.class);
        JavaCompilerFactory javaCompilerFactory = getServices().get(JavaCompilerFactory.class);
        GroovyCompilerFactory groovyCompilerFactory = new GroovyCompilerFactory(projectInternal, javaCompilerFactory, compilerDaemonManager, inProcessCompilerDaemonFactory);
        Compiler<GroovyJavaJointCompileSpec> delegatingCompiler = groovyCompilerFactory.newCompiler(spec);
        compiler = new CleaningGroovyCompiler(delegatingCompiler, getOutputs());
    }
    return compiler;
}
 

public WorkResult execute(T spec) {
    StaleClassCleaner cleaner = createCleaner(spec);

    cleaner.setDestinationDir(spec.getDestinationDir());
    cleaner.setSource(spec.getSource());
    cleaner.execute();

    Compiler<? super T> compiler = getCompiler();
    return compiler.execute(spec);
}
 

public Compiler<GroovyJavaJointCompileSpec> newCompiler(GroovyJavaJointCompileSpec spec) {
    CompileOptions javaOptions = spec.getCompileOptions();
    GroovyCompileOptions groovyOptions = spec.getGroovyCompileOptions();
    Compiler<JavaCompileSpec> javaCompiler = javaCompilerFactory.createForJointCompilation(javaOptions);
    Compiler<GroovyJavaJointCompileSpec> groovyCompiler = new ApiGroovyCompiler(javaCompiler);
    CompilerDaemonFactory daemonFactory;
    if (groovyOptions.isFork()) {
        daemonFactory = compilerDaemonFactory;
    } else {
        daemonFactory = inProcessCompilerDaemonFactory;
    }
    groovyCompiler = new DaemonGroovyCompiler(project.getRootProject().getProjectDir(), groovyCompiler, project.getServices().get(ClassPathRegistry.class), daemonFactory);
    return new NormalizingGroovyCompiler(groovyCompiler);
}
 

public <T extends CompileSpec> Compiler<T> newCompiler(T spec) {
    if (spec instanceof CppCompileSpec) {
        return castCompiler(createCppCompiler());
    }
    if (spec instanceof CCompileSpec) {
        return castCompiler(createCCompiler());
    }
    if (spec instanceof ObjectiveCppCompileSpec) {
        throw new RuntimeException("Objective-C++ is not available on the Visual C++ toolchain");
    }
    if (spec instanceof ObjectiveCCompileSpec) {
        throw new RuntimeException("Objective-C is not available on the Visual C++ toolchain");
    }
    if (spec instanceof WindowsResourceCompileSpec) {
        return castCompiler(createWindowsResourceCompiler());
    }
    if (spec instanceof AssembleSpec) {
        return castCompiler(createAssembler());
    }
    if (spec instanceof LinkerSpec) {
        return castCompiler(createLinker());
    }
    if (spec instanceof StaticLibraryArchiverSpec) {
        return castCompiler(createStaticLibraryArchiver());
    }
    throw new IllegalArgumentException(String.format("Don't know how to compile from a spec of type %s.", spec.getClass().getSimpleName()));
}
 

public <T extends CompileSpec> void execute(Compiler<T> compiler, T spec) {
    try {
        LOGGER.info("Executing {} in compiler daemon.", compiler);
        WorkResult result = compiler.execute(spec);
        LOGGER.info("Successfully executed {} in compiler daemon.", compiler);
        client.executed(new CompileResult(result.getDidWork(), null));
    } catch (Throwable t) {
        LOGGER.info("Exception executing {} in compiler daemon: {}.", compiler, t);
        client.executed(new CompileResult(true, t));
    }
}
 

private void executeExternalJavadoc() {
    JavadocSpec spec = new JavadocSpec();
    spec.setExecutable(executable);
    spec.setOptions(options);
    spec.setIgnoreFailures(!failOnError);
    spec.setWorkingDir(getProject().getProjectDir());
    spec.setOptionsFile(getOptionsFile());

    Compiler<JavadocSpec> generator = ((JavaToolChainInternal) getToolChain()).select(null).newCompiler(spec);
    generator.execute(spec);
}
 

public <T extends CompileSpec> Compiler<T> newCompiler(T spec) {
    if (spec instanceof CppCompileSpec) {
        return castCompiler(createCppCompiler());
    }
    if (spec instanceof CCompileSpec) {
        return castCompiler(createCCompiler());
    }
    if (spec instanceof ObjectiveCppCompileSpec) {
        throw new RuntimeException("Objective-C++ is not available on the Visual C++ toolchain");
    }
    if (spec instanceof ObjectiveCCompileSpec) {
        throw new RuntimeException("Objective-C is not available on the Visual C++ toolchain");
    }
    if (spec instanceof WindowsResourceCompileSpec) {
        return castCompiler(createWindowsResourceCompiler());
    }
    if (spec instanceof AssembleSpec) {
        return castCompiler(createAssembler());
    }
    if (spec instanceof LinkerSpec) {
        return castCompiler(createLinker());
    }
    if (spec instanceof StaticLibraryArchiverSpec) {
        return castCompiler(createStaticLibraryArchiver());
    }
    throw new IllegalArgumentException(String.format("Don't know how to compile from a spec of type %s.", spec.getClass().getSimpleName()));
}
 

public CleaningJavaCompiler(Compiler<JavaCompileSpec> compiler, Factory<AntBuilder> antBuilderFactory,
                            TaskOutputsInternal taskOutputs) {
    this.compiler = compiler;
    this.antBuilderFactory = antBuilderFactory;
    this.taskOutputs = taskOutputs;
}
 

public Compiler<JavaCompileSpec> createForJointCompilation(CompileOptions options) {
    return createTargetCompiler(options, true);
}
 

private CleaningJavaCompiler createCompiler(JavaCompileSpec spec) {
    // TODO:DAZ Supply the target platform to the task, using the compatibility flags as overrides
    // Or maybe split the legacy compile task from the new one
    Compiler<JavaCompileSpec> javaCompiler = ((JavaToolChainInternal) getToolChain()).select(getPlatform()).newCompiler(spec);
    return new CleaningJavaCompiler(javaCompiler, getAntBuilderFactory(), getOutputs());
}
 

public Compiler<CCompileSpec> createCCompiler() {
    CommandLineTool commandLineTool = tool("C compiler", visualCpp.getCompiler(targetPlatform));
    CCompiler cCompiler = new CCompiler(commandLineTool, invocation(commandLineToolConfigurations.get(ToolType.C_COMPILER)), addIncludePathAndDefinitions(CCompileSpec.class));
    return new OutputCleaningCompiler<CCompileSpec>(cCompiler, ".obj");
}
 

public DefaultScalaJavaJointCompiler(Compiler<ScalaCompileSpec> scalaCompiler, Compiler<JavaCompileSpec> javaCompiler) {
    this.scalaCompiler = scalaCompiler;
    this.javaCompiler = javaCompiler;
}
 

@Override
public Compiler<JavaCompileSpec> getCompiler() {
    return compiler;
}
 

@Override
public Compiler<JavaCompileSpec> getCompiler() {
    return compiler;
}
 

public Compiler<LinkerSpec> createLinker() {
    CommandLineTool commandLineTool = tool("Linker", visualCpp.getLinker(targetPlatform));
    return new LinkExeLinker(commandLineTool, invocation(commandLineToolConfigurations.get(ToolType.LINKER)), addLibraryPath());
}