pFad - Phonifier reborn

diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 00000000..1a6f7b71 --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,20 @@ +version: 2 +updates: + - package-ecosystem: "maven" + directory: "/" + schedule: + interval: "weekly" + groups: + dependencies: + applies-to: version-updates + patterns: + - "*" + - package-ecosystem: "github-actions" + directory: "/" + schedule: + interval: "monthly" + groups: + github-actions: + applies-to: version-updates + patterns: + - "*" diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 00000000..6b7e2ae7 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,37 @@ +name: CI + +on: + push: + branches: + - main + pull_request: + branches: + - main + +jobs: + test: + name: "JDK ${{ matrix.java }}" + strategy: + matrix: + java: [ 8, 11, 17, 21 ] + runs-on: ubuntu-latest + steps: + # Cancel any previous runs for the same branch that are still running. + - name: 'Cancel previous runs' + uses: styfle/cancel-workflow-action@85880fa0301c86cca9da44039ee3bb12d3bedbfa + with: + access_token: ${{ github.token }} + - name: 'Check out repository' + uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 + - name: 'Set up JDK ${{ matrix.java }}' + uses: actions/setup-java@c5195efecf7bdfc987ee8bae7a71cb8b11521c00 + with: + java-version: ${{ matrix.java }} + distribution: 'zulu' + cache: 'maven' + - name: 'Install' + shell: bash + run: mvn -B -U install clean --fail-never --quiet -DskipTests=true -Dinvoker.skip=true + - name: 'Test' + shell: bash + run: mvn -B verify diff --git a/.travis.yml b/.travis.yml deleted file mode 100644 index e833e7a6..00000000 --- a/.travis.yml +++ /dev/null @@ -1,14 +0,0 @@ -language: java -install: mvn -U install clean --fail-never --quiet -DskipTests=true -Dinvoker.skip=true -script: mvn verify - -jdk: - - openjdk7 - - oraclejdk7 - -notifications: - email: false - -branches: - except: - - gh-pages diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 650b0483..51438eaa 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -1,22 +1,18 @@ Contributing ============ -If you would like to contribute code to Autofactory you can do so through GitHub -by forking the repository and sending a pull request. +If you would like to contribute code to compile-testing you can do so through +GitHub by forking the repository and sending a pull request. When submitting code, please make every effort to follow existing conventions -and style in order to keep the code as readable as possible. +and style in order to keep the code as readable as possible. Where appropriate, please provide unit tests or integration tests. Unit tests should be JUnit based tests and can use either standard JUnit assertions or -Truth assertions and be added to `/src/test/java`. Changes to -code generation or other build-time behaviour should go into small maven -projects using the `maven-invoker-plugin`. Examples of this are in -`generator/src/it` and can include bean-shell verification scripts and other -facilities provided by `maven-invoker-plugin`. +Truth assertions and be added to `/src/test/java`. Please make sure your code compiles by running `mvn clean verify` which will -execute both unit and integration test phases. Additionally, consider using +execute both unit and integration test phases. Additionally, consider using http://travis-ci.org to validate your branches before you even put them into pull requests. All pull requests will be validated by Travis-ci in any case and must pass before being merged. diff --git a/README.md b/README.md index 2bf7f31a..a7fa2b74 100644 --- a/README.md +++ b/README.md @@ -1,21 +1,11 @@ Compile Testing =============== -A library for testing javac compilation with or without annotation processors. See the [javadoc][package-info] for usage examples. +[![Build Status][ci-shield]][ci-link] +[![Maven Release][maven-shield]][maven-link] +[![Javadoc][javadoc-shield]][javadoc-link] -Latest Release --------------- - -The latest release is version `0.5`. Include it as a [Maven](http://maven.apache.org/) dependency with the following snippet: - -``` - - com.google.testing.compile - compile-testing - 0.5 - test - -``` +A library for testing javac compilation with or without annotation processors. See the [javadoc][javadoc-link] for usage examples. License ------- @@ -34,4 +24,9 @@ License See the License for the specific language governing permissions and limitations under the License. -[package-info]: https://github.com/google/compile-testing/blob/master/src/main/java/com/google/testing/compile/package-info.java +[ci-shield]: https://github.com/google/compile-testing/actions/workflows/ci.yml/badge.svg?branch=main +[ci-link]: https://github.com/google/compile-testing/actions +[maven-shield]: https://img.shields.io/maven-central/v/com.google.testing.compile/compile-testing.png +[maven-link]: https://search.maven.org/artifact/com.google.testing.compile/compile-testing +[javadoc-shield]: https://javadoc.io/badge/com.google.testing.compile/compile-testing.svg?color=blue +[javadoc-link]: https://javadoc.io/doc/com.google.testing.compile/compile-testing diff --git a/pom.xml b/pom.xml index 6dc09561..42811bd9 100644 --- a/pom.xml +++ b/pom.xml @@ -1,25 +1,26 @@ 4.0.0 - - org.sonatype.oss - oss-parent - 7 - - com.google.testing.compile compile-testing - 0.6-SNAPSHOT + HEAD-SNAPSHOT Compile Testing Utilities for testing compilation. + + 1.4.4 + + http://github.com/google/compile-testing + GitHub http://github.com/google/compile-testing/issues + 2013 + The Apache Software License, Version 2.0 @@ -27,54 +28,87 @@ repo + - 3.0.3 + 3.5.0 + scm:git:http://github.com/google/compile-testing scm:git:git@github.com:google/compile-testing.git http://github.com/google/compile-testing HEAD + + + + sonatype-nexus-snapshots + https://central.sonatype.com/repository/maven-snapshots/ + + + junit junit - 4.11 + 4.13.2 com.google.truth truth - 1.0-SNAPSHOT + ${truth.version} + + + com.google.truth.extensions + truth-java8-extension + ${truth.version} + test com.google.guava guava - 16.0.1 + 33.4.8-jre - com.sun - tools - ${java.version} - system - ${toolsjar} + com.google.errorprone + error_prone_annotations + 2.41.0 + provided - com.google.code.findbugs - jsr305 - 1.3.9 - true + com.google.auto.value + auto-value + 1.11.0 + + + com.google.auto + auto-common + 1.2.2 + + + org.jspecify + jspecify + 1.0.0 + + + + . + + LICENSE.txt + + META-INF + + - org.apache.maven.plugins maven-compiler-plugin - 3.1 + 3.14.0 - 1.6 - 1.6 + 1.8 + 1.8 -Xlint:all true true @@ -82,49 +116,92 @@ maven-release-plugin - 2.4.1 + 3.1.1 - release + sonatype-oss-release deploy + + maven-jar-plugin + 3.4.2 + + + maven-javadoc-plugin + 3.11.2 + + + --add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED + --add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED + --add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED + + + + + maven-site-plugin + 3.21.0 + + + org.apache.maven.plugins + maven-surefire-plugin + 3.5.3 + + ${test.jvm.flags} + + + - default-profile + tools-jar - true + false ${java.home}/../lib/tools.jar - - ${java.home}/../lib/tools.jar - + + + com.sun + tools + ${java.version} + system + ${java.home}/../lib/tools.jar + + - mac-profile + classes-jar false ${java.home}/../Classes/classes.jar - - ${java.home}/../Classes/classes.jar - + + + com.sun + tools + ${java.version} + system + + + ${java.home}/../Classes/classes.jar + + - release + sonatype-oss-release false + org.apache.maven.plugins maven-gpg-plugin - 1.4 + 3.2.8 sign-artifacts @@ -134,8 +211,9 @@ + org.apache.maven.plugins maven-source-plugin - 2.1.2 + 3.3.1 attach-sources @@ -144,8 +222,9 @@ + org.apache.maven.plugins maven-javadoc-plugin - 2.8 + 3.11.2 attach-docs @@ -153,8 +232,33 @@ + + org.sonatype.central + central-publishing-maven-plugin + 0.8.0 + true + + central + + + + add-exports + + [9,) + + + + --add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED + --add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED + --add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED + --add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED + --add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED + --add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED + + + diff --git a/src/main/java/com/google/testing/compile/Breadcrumbs.java b/src/main/java/com/google/testing/compile/Breadcrumbs.java index a65b18b9..b5adef93 100644 --- a/src/main/java/com/google/testing/compile/Breadcrumbs.java +++ b/src/main/java/com/google/testing/compile/Breadcrumbs.java @@ -19,7 +19,6 @@ import com.google.common.base.Joiner; import com.google.common.collect.FluentIterable; import com.google.common.collect.Lists; - import com.sun.source.tree.BlockTree; import com.sun.source.tree.BreakTree; import com.sun.source.tree.ClassTree; @@ -37,7 +36,6 @@ import com.sun.source.tree.VariableTree; import com.sun.source.util.SimpleTreeVisitor; import com.sun.source.util.TreePath; - import java.util.List; /** @@ -54,9 +52,6 @@ private Breadcrumbs() {} * Returns a string describing the {@link TreePath} given. */ static String describeTreePath(TreePath path) { - // TODO(spratt) The number of extra strings this creates by building a list of strings, - // and then joining it is at least a little wasteful. Consider modifying the BreadcrumbVisitor - // to take a StringBuilder and traverse the whole path. return Joiner.on("->").join(getBreadcrumbList(path)); } diff --git a/src/main/java/com/google/testing/compile/Compilation.java b/src/main/java/com/google/testing/compile/Compilation.java index cc846624..57342b41 100644 --- a/src/main/java/com/google/testing/compile/Compilation.java +++ b/src/main/java/com/google/testing/compile/Compilation.java @@ -15,193 +15,267 @@ */ package com.google.testing.compile; -import static com.google.common.base.Charsets.UTF_8; -import static javax.tools.JavaFileObject.Kind.SOURCE; +import static com.google.common.base.Preconditions.checkState; +import static com.google.testing.compile.JavaFileObjects.asByteSource; +import static java.util.Objects.requireNonNull; +import static java.util.stream.Collectors.collectingAndThen; +import static java.util.stream.Collectors.toList; +import static javax.tools.Diagnostic.Kind.ERROR; +import static javax.tools.Diagnostic.Kind.MANDATORY_WARNING; +import static javax.tools.Diagnostic.Kind.NOTE; +import static javax.tools.Diagnostic.Kind.WARNING; +import static javax.tools.JavaFileObject.Kind.CLASS; +import static javax.tools.StandardLocation.SOURCE_OUTPUT; -import com.google.common.base.Function; -import com.google.common.base.Objects; import com.google.common.collect.ImmutableList; -import com.google.common.collect.ImmutableListMultimap; import com.google.common.collect.ImmutableSet; -import com.google.common.collect.Multimaps; - -import com.sun.source.tree.CompilationUnitTree; -import com.sun.source.util.JavacTask; -import com.sun.source.util.Trees; -import com.sun.tools.javac.api.JavacTool; - +import com.google.common.collect.Sets; import java.io.IOException; -import java.util.List; -import java.util.Locale; - -import javax.annotation.processing.Processor; +import java.util.Optional; +import java.util.stream.Collector; import javax.tools.Diagnostic; -import javax.tools.DiagnosticCollector; -import javax.tools.JavaCompiler; -import javax.tools.JavaCompiler.CompilationTask; +import javax.tools.Diagnostic.Kind; +import javax.tools.JavaFileManager.Location; import javax.tools.JavaFileObject; -import javax.tools.ToolProvider; -/** - * Utilities for performing compilation with {@code javac}. - * - * @author Gregory Kick - */ -final class Compilation { - private Compilation() {} +/** The results of {@linkplain Compiler#compile compiling} source files. */ +public final class Compilation { + + private final Compiler compiler; + private final ImmutableList sourceFiles; + private final Status status; + private final ImmutableList> diagnostics; + private final ImmutableList generatedFiles; + + Compilation( + Compiler compiler, + Iterable sourceFiles, + boolean successful, + Iterable> diagnostics, + Iterable generatedFiles) { + this.compiler = compiler; + this.sourceFiles = ImmutableList.copyOf(sourceFiles); + this.status = successful ? Status.SUCCESS : Status.FAILURE; + this.diagnostics = ImmutableList.copyOf(diagnostics); + this.generatedFiles = ImmutableList.copyOf(generatedFiles); + } + + /** The compiler. */ + public Compiler compiler() { + return compiler; + } + + /** The source files compiled. */ + public ImmutableList sourceFiles() { + return sourceFiles; + } + + /** The status of the compilation. */ + public Status status() { + return status; + } /** - * Compile {@code sources} using {@code processors}. + * All diagnostics reported during compilation. The order of the returned list is unspecified. * - * @throws RuntimeException if compilation fails. + * @see #errors() + * @see #warnings() + * @see #notes() */ - static Result compile(Iterable processors, - Iterable sources) { - JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); - DiagnosticCollector diagnosticCollector = - new DiagnosticCollector(); - InMemoryJavaFileManager fileManager = new InMemoryJavaFileManager( - compiler.getStandardFileManager(diagnosticCollector, Locale.getDefault(), UTF_8)); - CompilationTask task = compiler.getTask( - null, // explicitly use the default because old versions of javac log some output on stderr - fileManager, - diagnosticCollector, - ImmutableSet.of(), - ImmutableSet.of(), - sources); - task.setProcessors(processors); - boolean successful = task.call(); - return new Result(successful, sortDiagnosticsByKind(diagnosticCollector.getDiagnostics()), - fileManager.getOutputFiles()); + public ImmutableList> diagnostics() { + return diagnostics; + } + + /** {@linkplain Diagnostic.Kind#ERROR Errors} reported during compilation. */ + public ImmutableList> errors() { + return diagnosticsOfKind(ERROR); } /** - * Parse {@code sources} into {@linkplain CompilationUnitTree compilation units}. This method - * does not compile the sources. + * {@linkplain Diagnostic.Kind#WARNING Warnings} (including {@linkplain + * Diagnostic.Kind#MANDATORY_WARNING mandatory warnings}) reported during compilation. */ - static ParseResult parse(Iterable sources) { - JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); - DiagnosticCollector diagnosticCollector = - new DiagnosticCollector(); - InMemoryJavaFileManager fileManager = new InMemoryJavaFileManager( - compiler.getStandardFileManager(diagnosticCollector, Locale.getDefault(), UTF_8)); - JavacTask task = ((JavacTool) compiler).getTask( - null, // explicitly use the default because old versions of javac log some output on stderr - fileManager, - diagnosticCollector, - ImmutableSet.of(), - ImmutableSet.of(), - sources); - try { - Iterable parsedCompilationUnits = task.parse(); - List> diagnostics = diagnosticCollector.getDiagnostics(); - for (Diagnostic diagnostic : diagnostics) { - if (Diagnostic.Kind.ERROR == diagnostic.getKind()) { - throw new IllegalStateException("error while parsing:\n" - + Diagnostics.toString(diagnostics)); - } - } - return new ParseResult(sortDiagnosticsByKind(diagnostics), parsedCompilationUnits, - Trees.instance(task)); - } catch (IOException e) { - throw new RuntimeException(e); - } + public ImmutableList> warnings() { + return diagnosticsOfKind(WARNING, MANDATORY_WARNING); } - private static ImmutableListMultimap> - sortDiagnosticsByKind(Iterable> diagnostics) { - return Multimaps.index(diagnostics, - new Function, Diagnostic.Kind>() { - @Override public Diagnostic.Kind apply(Diagnostic input) { - return input.getKind(); - } - }); + /** {@linkplain Diagnostic.Kind#NOTE Notes} reported during compilation. */ + public ImmutableList> notes() { + return diagnosticsOfKind(NOTE); + } + + ImmutableList> diagnosticsOfKind(Kind kind, Kind... more) { + ImmutableSet kinds = Sets.immutableEnumSet(kind, more); + return diagnostics() + .stream() + .filter(diagnostic -> kinds.contains(diagnostic.getKind())) + .collect(toImmutableList()); } /** - * The diagnostic, parse trees, and {@link Trees} instance for a parse task. + * Files generated during compilation. * - *

Note: It is possible for the {@link Trees} instance contained within a {@code ParseResult} - * to be invalidated by a call to {@link com.sun.tools.javac.api.JavacTaskImpl#cleanup()}. Though - * we do not currently expose the {@link JavacTask} used to create a {@code ParseResult} to - * {@code cleanup()} calls on its underlying implementation, this should be acknowledged as an - * implementation detail that could cause unexpected behavior when making calls to methods in - * {@link Trees}. + * @throws IllegalStateException for {@linkplain #status() failed compilations}, since the state + * of the generated files is undefined in that case */ - static final class ParseResult { - private final ImmutableListMultimap> - diagnostics; - private final ImmutableList compilationUnits; - private final Trees trees; - - ParseResult( - ImmutableListMultimap> diagnostics, - Iterable compilationUnits, Trees trees) { - this.trees = trees; - this.compilationUnits = ImmutableList.copyOf(compilationUnits); - this.diagnostics = diagnostics; - } + public ImmutableList generatedFiles() { + checkState( + status.equals(Status.SUCCESS), + "compilation failed, so generated files are unavailable. %s", + describeFailureDiagnostics()); + return generatedFiles; + } - ImmutableListMultimap> - diagnosticsByKind() { - return diagnostics; - } + /** + * Source files generated during compilation. + * + * @throws IllegalStateException for {@linkplain #status() failed compilations}, since the state + * of the generated files is undefined in that case + */ + public ImmutableList generatedSourceFiles() { + return generatedFiles() + .stream() + .filter(generatedFile -> generatedFile.getKind().equals(JavaFileObject.Kind.SOURCE)) + .collect(toImmutableList()); + } + + /** + * Returns the file at {@code path} if one was generated. + * + *

For example: + * + *

+   * {@code Optional} fooClassFile =
+   *     compilation.generatedFile(CLASS_OUTPUT, "com/google/myapp/Foo.class");
+   *

+ * + * @throws IllegalStateException for {@linkplain #status() failed compilations}, since the state + * of the generated files is undefined in that case + */ + public Optional generatedFile(Location location, String path) { + // We're relying on the implementation of location.getName() to be equivalent to the first + // part of the path. + String expectedFilename = String.format("%s/%s", location.getName(), path); + return generatedFiles().stream() + .filter(generated -> requireNonNull(generated.toUri().getPath()).endsWith(expectedFilename)) + .findFirst(); + } + + /** + * Returns the file with name {@code fileName} in package {@code packageName} if one was + * generated. + * + *

For example: + * + *

+   * {@code Optional} fooClassFile =
+   *     compilation.generatedFile(CLASS_OUTPUT, "com.google.myapp", "Foo.class");
+   *

+ * + * @throws IllegalStateException for {@linkplain #status() failed compilations}, since the state + * of the generated files is undefined in that case + */ + public Optional generatedFile( + Location location, String packageName, String fileName) { + return generatedFile( + location, + packageName.isEmpty() ? fileName : packageName.replace('.', '/') + '/' + fileName); + } - Iterable compilationUnits() { - return compilationUnits; + /** + * Returns the source file for the type with a given qualified name (no ".java" extension) if one + * was generated. + * + *

For example: + * + *

+   * {@code Optional} fooSourceFile =
+   *     compilation.generatedSourceFile("com.google.myapp.Foo");
+   *

+ * + * @throws IllegalStateException for {@linkplain #status() failed compilations}, since the state + * of the generated files is undefined in that case + */ + public Optional generatedSourceFile(String qualifiedName) { + int lastIndexOfDot = qualifiedName.lastIndexOf('.'); + String packageName = lastIndexOfDot == -1 ? "" : qualifiedName.substring(0, lastIndexOfDot); + String fileName = qualifiedName.substring(lastIndexOfDot + 1) + ".java"; + return generatedFile(SOURCE_OUTPUT, packageName, fileName); + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + builder + .append("compilation of ") + .append(sourceFiles.stream().map(JavaFileObject::getName).collect(toList())); + if (!compiler.processors().isEmpty()) { + builder.append(" using annotation processors ").append(compiler.processors()); + } + if (!compiler.options().isEmpty()) { + builder.append(" passing options ").append(compiler.options()); } + return builder.toString(); + } - Trees trees() { - return trees; + /** Returns a description of the why the compilation failed. */ + String describeFailureDiagnostics() { + ImmutableList> diagnostics = diagnostics(); + if (diagnostics.isEmpty()) { + return "Compilation produced no diagnostics.\n"; } + StringBuilder message = new StringBuilder("Compilation produced the following diagnostics:\n"); + diagnostics.forEach(diagnostic -> message.append(diagnostic).append('\n')); + return message.toString(); } - /** The diagnostic and file output of a compilation. */ - static final class Result { - private final boolean successful; - private final ImmutableListMultimap> - diagnostics; - private final ImmutableListMultimap generatedFilesByKind; - - Result(boolean successful, - ImmutableListMultimap> diagnostics, - Iterable generatedFiles) { - this.successful = successful; - this.diagnostics = diagnostics; - this.generatedFilesByKind = Multimaps.index(generatedFiles, - new Function() { - @Override public JavaFileObject.Kind apply(JavaFileObject input) { - return input.getKind(); - } - }); - if (!successful && diagnostics.get(Diagnostic.Kind.ERROR).isEmpty()) { - throw new CompilationFailureException(); + /** Returns a description of the source file generated by this compilation. */ + String describeGeneratedSourceFiles() { + ImmutableList generatedSourceFiles = + generatedFiles + .stream() + .filter(generatedFile -> generatedFile.getKind().equals(JavaFileObject.Kind.SOURCE)) + .collect(toImmutableList()); + if (generatedSourceFiles.isEmpty()) { + return "No files were generated.\n"; + } else { + StringBuilder message = new StringBuilder("Generated Source Files\n======================\n"); + for (JavaFileObject generatedFile : generatedSourceFiles) { + message.append(describeGeneratedFile(generatedFile)); } + return message.toString(); } + } - boolean successful() { - return successful; + /** Returns a description of the contents of a given generated file. */ + private String describeGeneratedFile(JavaFileObject generatedFile) { + try { + StringBuilder entry = new StringBuilder("\n").append(generatedFile.getName()).append(":\n"); + if (generatedFile.getKind().equals(CLASS)) { + entry.append( + String.format( + " [generated class file (%d bytes)]", asByteSource(generatedFile).size())); + } else { + entry.append(generatedFile.getCharContent(true)); + } + return entry.append('\n').toString(); + } catch (IOException e) { + throw new IllegalStateException( + "Couldn't read from JavaFileObject when it was already in memory.", e); } + } - ImmutableListMultimap> - diagnosticsByKind() { - return diagnostics; - } + private static Collector> toImmutableList() { + return collectingAndThen(toList(), ImmutableList::copyOf); + } - ImmutableListMultimap generatedFilesByKind() { - return generatedFilesByKind; - } + /** The status of a compilation. */ + public enum Status { - ImmutableList generatedSources() { - return generatedFilesByKind.get(SOURCE); - } + /** Compilation finished without errors. */ + SUCCESS, - @Override - public String toString() { - return Objects.toStringHelper(this) - .add("successful", successful) - .add("diagnostics", diagnostics) - .toString(); - } + /** Compilation finished with errors. */ + FAILURE, } } diff --git a/src/main/java/com/google/testing/compile/CompilationFailureException.java b/src/main/java/com/google/testing/compile/CompilationFailureException.java index 035bafbc..114a67ec 100644 --- a/src/main/java/com/google/testing/compile/CompilationFailureException.java +++ b/src/main/java/com/google/testing/compile/CompilationFailureException.java @@ -20,9 +20,11 @@ */ @SuppressWarnings("serial") public class CompilationFailureException extends RuntimeException { - CompilationFailureException() { - super("Compilation failed, but did not report any error diagnostics or throw any exceptions. " - + "This behavior has been observed in older versions of javac, which swallow exceptions " - + "and log them on System.err. Check there for more information."); + CompilationFailureException(Compilation compilation) { + super( + compilation + + " failed, but did not report any error diagnostics or throw any exceptions. " + + "This behavior has been observed in older versions of javac, which swallow " + + "exceptions and log them on System.err. Check there for more information."); } } diff --git a/src/main/java/com/google/testing/compile/CompilationRule.java b/src/main/java/com/google/testing/compile/CompilationRule.java index 4a319e84..d54e05ba 100644 --- a/src/main/java/com/google/testing/compile/CompilationRule.java +++ b/src/main/java/com/google/testing/compile/CompilationRule.java @@ -16,20 +16,11 @@ package com.google.testing.compile; import static com.google.common.base.Preconditions.checkState; +import static com.google.testing.compile.Compilation.Status.SUCCESS; +import static com.google.testing.compile.Compiler.javac; -import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; -import com.google.testing.compile.Compilation.Result; - -import org.junit.Rule; -import org.junit.rules.TestRule; -import org.junit.runner.Description; -import org.junit.runners.JUnit4; -import org.junit.runners.model.Statement; - import java.util.Set; -import java.util.concurrent.atomic.AtomicReference; - import javax.annotation.processing.AbstractProcessor; import javax.annotation.processing.ProcessingEnvironment; import javax.annotation.processing.RoundEnvironment; @@ -37,68 +28,43 @@ import javax.lang.model.element.TypeElement; import javax.lang.model.util.Elements; import javax.lang.model.util.Types; +import javax.tools.JavaFileObject; +import org.junit.Rule; +import org.junit.rules.TestRule; +import org.junit.runner.Description; +import org.junit.runners.JUnit4; +import org.junit.runners.model.Statement; /** * A {@link JUnit4} {@link Rule} that executes tests such that a instances of {@link Elements} and * {@link Types} are available during execution. * - *

To use this rule in a test, just add the following field:

   {@code
- *   @Rule public CompilationRule compilationRule = new CompilationRule();}
+ * To use this rule in a test, just add the following field:
+ *
+ * 
{@code @Rule} public CompilationRule compilationRule = new CompilationRule();
  *
  * @author Gregory Kick
  */
 public final class CompilationRule implements TestRule {
+  private static final JavaFileObject DUMMY =
+      JavaFileObjects.forSourceLines("Dummy", "final class Dummy {}");
+
   private Elements elements;
   private Types types;
 
   @Override
   public Statement apply(final Statement base, Description description) {
     return new Statement() {
-      @Override public void evaluate() throws Throwable {
-        final AtomicReference thrown = new AtomicReference();
-        Result result = Compilation.compile(ImmutableList.of(new AbstractProcessor() {
-          @Override
-          public SourceVersion getSupportedSourceVersion() {
-            return SourceVersion.latest();
-          }
-
-          @Override
-          public Set getSupportedAnnotationTypes() {
-            return ImmutableSet.of("*");
-          }
-
-          @Override
-          public synchronized void init(ProcessingEnvironment processingEnv) {
-            super.init(processingEnv);
-            elements = processingEnv.getElementUtils();
-            types = processingEnv.getTypeUtils();
-          }
-
-          @Override
-          public boolean process(Set annotations,
-              RoundEnvironment roundEnv) {
-            // just run the test on the last round after compilation is over
-            if (roundEnv.processingOver()) {
-              try {
-                base.evaluate();
-              } catch (Throwable e) {
-                thrown.set(e);
-              }
-            }
-            return false;
-          }
-        }),
-        // just compile _something_
-        ImmutableList.of(JavaFileObjects.forSourceLines("Dummy", "final class Dummy {}")));
-        checkState(result.successful(), result);
-        Throwable t = thrown.get();
-        if (t != null) {
-          throw t;
-        }
+      @Override
+      public void evaluate() throws Throwable {
+        EvaluatingProcessor evaluatingProcessor = new EvaluatingProcessor(base);
+        Compilation compilation = javac().withProcessors(evaluatingProcessor).compile(DUMMY);
+        checkState(compilation.status().equals(SUCCESS), compilation);
+        evaluatingProcessor.throwIfStatementThrew();
       }
     };
   }
-
+  
   /**
    * Returns the {@link Elements} instance associated with the current execution of the rule.
    *
@@ -115,7 +81,54 @@ public Elements getElements() {
    * @throws IllegalStateException if this method is invoked outside the execution of the rule.
    */
   public Types getTypes() {
-    checkState(elements != null, "Not running within the rule");
+    checkState(types != null, "Not running within the rule");
     return types;
   }
+
+  final class EvaluatingProcessor extends AbstractProcessor {
+
+    final Statement base;
+    Throwable thrown;
+
+    EvaluatingProcessor(Statement base) {
+      this.base = base;
+    }
+
+    @Override
+    public SourceVersion getSupportedSourceVersion() {
+      return SourceVersion.latest();
+    }
+
+    @Override
+    public Set getSupportedAnnotationTypes() {
+      return ImmutableSet.of("*");
+    }
+
+    @Override
+    public synchronized void init(ProcessingEnvironment processingEnv) {
+      super.init(processingEnv);
+      elements = processingEnv.getElementUtils();
+      types = processingEnv.getTypeUtils();
+    }
+
+    @Override
+    public boolean process(Set annotations, RoundEnvironment roundEnv) {
+      // just run the test on the last round after compilation is over
+      if (roundEnv.processingOver()) {
+        try {
+          base.evaluate();
+        } catch (Throwable e) {
+          thrown = e;
+        }
+      }
+      return false;
+    }
+
+    /** Throws what the base {@link Statement} threw, if anything. */
+    void throwIfStatementThrew() throws Throwable {
+      if (thrown != null) {
+        throw thrown;
+      }
+    }
+  }
 }
diff --git a/src/main/java/com/google/testing/compile/CompilationSubject.java b/src/main/java/com/google/testing/compile/CompilationSubject.java
new file mode 100644
index 00000000..22b093ba
--- /dev/null
+++ b/src/main/java/com/google/testing/compile/CompilationSubject.java
@@ -0,0 +1,606 @@
+/*
+ * Copyright (C) 2013 Google, Inc.
+ *
+ * Licensed 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.
+ */
+package com.google.testing.compile;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Predicates.notNull;
+import static com.google.common.collect.Iterables.size;
+import static com.google.common.truth.Fact.fact;
+import static com.google.common.truth.Fact.simpleFact;
+import static com.google.common.truth.Truth.assertAbout;
+import static com.google.testing.compile.Compilation.Status.FAILURE;
+import static com.google.testing.compile.Compilation.Status.SUCCESS;
+import static com.google.testing.compile.JavaFileObjectSubject.javaFileObjects;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static java.util.Objects.requireNonNull;
+import static java.util.stream.Collectors.collectingAndThen;
+import static java.util.stream.Collectors.joining;
+import static java.util.stream.Collectors.toList;
+import static javax.tools.Diagnostic.Kind.ERROR;
+import static javax.tools.Diagnostic.Kind.MANDATORY_WARNING;
+import static javax.tools.Diagnostic.Kind.NOTE;
+import static javax.tools.Diagnostic.Kind.WARNING;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Streams;
+import com.google.common.truth.Fact;
+import com.google.common.truth.FailureMetadata;
+import com.google.common.truth.Subject;
+import com.google.common.truth.Truth;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.regex.Pattern;
+import java.util.stream.Collector;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import javax.tools.Diagnostic;
+import javax.tools.JavaFileManager.Location;
+import javax.tools.JavaFileObject;
+import javax.tools.StandardLocation;
+import org.jspecify.annotations.Nullable;
+
+/** A {@link Truth} subject for a {@link Compilation}. */
+public final class CompilationSubject extends Subject {
+
+  private static final Subject.Factory FACTORY =
+      new CompilationSubjectFactory();
+
+  /** Returns a {@link Subject.Factory} for a {@link Compilation}. */
+  public static Subject.Factory compilations() {
+    return FACTORY;
+  }
+
+  /** Starts making assertions about a {@link Compilation}. */
+  public static CompilationSubject assertThat(Compilation actual) {
+    return assertAbout(compilations()).that(actual);
+  }
+
+  private final @Nullable Compilation actual;
+
+  CompilationSubject(FailureMetadata failureMetadata, @Nullable Compilation actual) {
+    super(failureMetadata, actual);
+    this.actual = actual;
+  }
+
+  /** Asserts that the compilation succeeded. */
+  public void succeeded() {
+    Compilation actual = actualNotNull();
+    if (actual.status().equals(FAILURE)) {
+      failWithoutActual(
+          simpleFact(actual.describeFailureDiagnostics() + actual.describeGeneratedSourceFiles()));
+    }
+  }
+
+  /** Asserts that the compilation succeeded without warnings. */
+  public void succeededWithoutWarnings() {
+    succeeded();
+    hadWarningCount(0);
+  }
+
+  /** Asserts that the compilation failed. */
+  public void failed() {
+    if (actualNotNull().status().equals(SUCCESS)) {
+      failWithoutActual(
+          simpleFact(
+              "Compilation was expected to fail, but contained no errors.\n\n"
+                  + actualNotNull().describeGeneratedSourceFiles()));
+    }
+  }
+
+  /** Asserts that the compilation had exactly {@code expectedCount} errors. */
+  public void hadErrorCount(int expectedCount) {
+    checkDiagnosticCount(expectedCount, ERROR);
+  }
+
+  /** Asserts that there was at least one error containing {@code expectedSubstring}. */
+  @CanIgnoreReturnValue
+  public DiagnosticInFile hadErrorContaining(String expectedSubstring) {
+    return hadDiagnosticContaining(expectedSubstring, ERROR);
+  }
+
+  /** Asserts that there was at least one error containing a match for {@code expectedPattern}. */
+  @CanIgnoreReturnValue
+  public DiagnosticInFile hadErrorContainingMatch(String expectedPattern) {
+    return hadDiagnosticContainingMatch(expectedPattern, ERROR);
+  }
+
+  /** Asserts that there was at least one error containing a match for {@code expectedPattern}. */
+  @CanIgnoreReturnValue
+  public DiagnosticInFile hadErrorContainingMatch(Pattern expectedPattern) {
+    return hadDiagnosticContainingMatch(expectedPattern, ERROR);
+  }
+
+  /** Asserts that the compilation had exactly {@code expectedCount} warnings. */
+  public void hadWarningCount(int expectedCount) {
+    checkDiagnosticCount(expectedCount, WARNING, MANDATORY_WARNING);
+  }
+
+  /** Asserts that there was at least one warning containing {@code expectedSubstring}. */
+  @CanIgnoreReturnValue
+  public DiagnosticInFile hadWarningContaining(String expectedSubstring) {
+    return hadDiagnosticContaining(expectedSubstring, WARNING, MANDATORY_WARNING);
+  }
+
+  /** Asserts that there was at least one warning containing a match for {@code expectedPattern}. */
+  @CanIgnoreReturnValue
+  public DiagnosticInFile hadWarningContainingMatch(String expectedPattern) {
+    return hadDiagnosticContainingMatch(expectedPattern, WARNING, MANDATORY_WARNING);
+  }
+
+  /** Asserts that there was at least one warning containing a match for {@code expectedPattern}. */
+  @CanIgnoreReturnValue
+  public DiagnosticInFile hadWarningContainingMatch(Pattern expectedPattern) {
+    return hadDiagnosticContainingMatch(expectedPattern, WARNING, MANDATORY_WARNING);
+  }
+
+  /** Asserts that the compilation had exactly {@code expectedCount} notes. */
+  public void hadNoteCount(int expectedCount) {
+    checkDiagnosticCount(expectedCount, NOTE);
+  }
+
+  /** Asserts that there was at least one note containing {@code expectedSubstring}. */
+  @CanIgnoreReturnValue
+  public DiagnosticInFile hadNoteContaining(String expectedSubstring) {
+    return hadDiagnosticContaining(expectedSubstring, NOTE);
+  }
+
+  /** Asserts that there was at least one note containing a match for {@code expectedPattern}. */
+  @CanIgnoreReturnValue
+  public DiagnosticInFile hadNoteContainingMatch(String expectedPattern) {
+    return hadDiagnosticContainingMatch(expectedPattern, NOTE);
+  }
+
+  /** Asserts that there was at least one note containing a match for {@code expectedPattern}. */
+  @CanIgnoreReturnValue
+  public DiagnosticInFile hadNoteContainingMatch(Pattern expectedPattern) {
+    return hadDiagnosticContainingMatch(expectedPattern, NOTE);
+  }
+
+  private void checkDiagnosticCount(
+      int expectedCount, Diagnostic.Kind kind, Diagnostic.Kind... more) {
+    Iterable> diagnostics =
+        actualNotNull().diagnosticsOfKind(kind, more);
+    int actualCount = size(diagnostics);
+    if (actualCount != expectedCount) {
+      failWithoutActual(
+          simpleFact(
+              messageListing(
+                  diagnostics,
+                  "Expected %d %s, but found the following %d %s:",
+                  expectedCount,
+                  kindPlural(kind),
+                  actualCount,
+                  kindPlural(kind))));
+    }
+  }
+
+  private static String messageListing(
+      Iterable> diagnostics, String headingFormat, Object... formatArgs) {
+    StringBuilder listing =
+        new StringBuilder(String.format(headingFormat, formatArgs)).append('\n');
+    for (Diagnostic diagnostic : diagnostics) {
+      listing.append(diagnostic.getMessage(null)).append('\n');
+    }
+    return listing.toString();
+  }
+
+  /** Returns the phrase describing one diagnostic of a kind. */
+  private static String kindSingular(Diagnostic.Kind kind) {
+    switch (kind) {
+      case ERROR:
+        return "an error";
+
+      case MANDATORY_WARNING:
+      case WARNING:
+        return "a warning";
+
+      case NOTE:
+        return "a note";
+
+      case OTHER:
+        return "a diagnostic message";
+
+      default:
+        throw new AssertionError(kind);
+    }
+  }
+
+  /** Returns the phrase describing several diagnostics of a kind. */
+  private static String kindPlural(Diagnostic.Kind kind) {
+    switch (kind) {
+      case ERROR:
+        return "errors";
+
+      case MANDATORY_WARNING:
+      case WARNING:
+        return "warnings";
+
+      case NOTE:
+        return "notes";
+
+      case OTHER:
+        return "diagnostic messages";
+
+      default:
+        throw new AssertionError(kind);
+    }
+  }
+
+  private DiagnosticInFile hadDiagnosticContaining(
+      String expectedSubstring, Diagnostic.Kind kind, Diagnostic.Kind... more) {
+    return hadDiagnosticContainingMatch(
+        String.format("containing \"%s\"", expectedSubstring),
+        Pattern.compile(Pattern.quote(expectedSubstring)),
+        kind,
+        more);
+  }
+
+  private DiagnosticInFile hadDiagnosticContainingMatch(
+      String expectedPattern, Diagnostic.Kind kind, Diagnostic.Kind... more) {
+    return hadDiagnosticContainingMatch(Pattern.compile(expectedPattern), kind, more);
+  }
+
+  private DiagnosticInFile hadDiagnosticContainingMatch(
+      Pattern expectedPattern, Diagnostic.Kind kind, Diagnostic.Kind... more) {
+    return hadDiagnosticContainingMatch(
+        String.format("containing match for /%s/", expectedPattern), expectedPattern, kind, more);
+  }
+
+  private DiagnosticInFile hadDiagnosticContainingMatch(
+      String diagnosticMatchDescription,
+      Pattern expectedPattern,
+      Diagnostic.Kind kind,
+      Diagnostic.Kind... more) {
+    String expectedDiagnostic =
+        String.format("%s %s", kindSingular(kind), diagnosticMatchDescription);
+    return new DiagnosticInFile(
+        expectedDiagnostic,
+        findMatchingDiagnostics(expectedDiagnostic, expectedPattern, kind, more));
+  }
+
+  /**
+   * Returns the diagnostics that match one of the kinds and a pattern. If none match, fails the
+   * test.
+   */
+  private ImmutableList> findMatchingDiagnostics(
+      String expectedDiagnostic,
+      Pattern expectedPattern,
+      Diagnostic.Kind kind,
+      Diagnostic.Kind... more) {
+    ImmutableList> diagnosticsOfKind =
+        actualNotNull().diagnosticsOfKind(kind, more);
+    ImmutableList> diagnosticsWithMessage =
+        diagnosticsOfKind
+            .stream()
+            .filter(diagnostic -> expectedPattern.matcher(diagnostic.getMessage(null)).find())
+            .collect(toImmutableList());
+    if (diagnosticsWithMessage.isEmpty()) {
+      failWithoutActual(
+          simpleFact(
+              messageListing(
+                  diagnosticsOfKind, "Expected %s, but only found:", expectedDiagnostic)));
+    }
+    return diagnosticsWithMessage;
+  }
+
+  /**
+   * Asserts that compilation generated a file named {@code fileName} in package {@code
+   * packageName}.
+   */
+  @CanIgnoreReturnValue
+  public JavaFileObjectSubject generatedFile(
+      Location location, String packageName, String fileName) {
+    String path = packageName.isEmpty() ? fileName : packageName.replace('.', '/') + '/' + fileName;
+    return generatedFile(location, path);
+  }
+
+  /** Asserts that compilation generated a file at {@code path}. */
+  @CanIgnoreReturnValue
+  public JavaFileObjectSubject generatedFile(Location location, String path) {
+    return checkGeneratedFile(actualNotNull().generatedFile(location, path), location, path);
+  }
+
+  /** Asserts that compilation generated a source file for a type with a given qualified name. */
+  @CanIgnoreReturnValue
+  public JavaFileObjectSubject generatedSourceFile(String qualifiedName) {
+    return generatedFile(
+        StandardLocation.SOURCE_OUTPUT, qualifiedName.replaceAll("\\.", "/") + ".java");
+  }
+
+  private static final JavaFileObject ALREADY_FAILED =
+      JavaFileObjects.forSourceLines(
+          "compile.Failure", "package compile;", "", "final class Failure {}");
+
+  private JavaFileObjectSubject checkGeneratedFile(
+      Optional generatedFile, Location location, String path) {
+    if (!generatedFile.isPresent()) {
+      // TODO(b/132162475): Use Facts if it becomes public API.
+      ImmutableList.Builder facts = ImmutableList.builder();
+      facts.add(fact("in location", location.getName()));
+      facts.add(simpleFact("it generated:"));
+      for (JavaFileObject generated : actualNotNull().generatedFiles()) {
+        if (requireNonNull(generated.toUri().getPath()).contains(location.getName())) {
+          facts.add(simpleFact("  " + generated.toUri().getPath()));
+        }
+      }
+      failWithoutActual(
+          fact("expected to generate file", "/" + path), facts.build().toArray(new Fact[0]));
+      return ignoreCheck().about(javaFileObjects()).that(ALREADY_FAILED);
+    }
+    return check("generatedFile(/%s)", path).about(javaFileObjects()).that(generatedFile.get());
+  }
+
+  private Compilation actualNotNull() {
+    isNotNull();
+    return checkNotNull(actual);
+  }
+
+  private static  Collector> toImmutableList() {
+    return collectingAndThen(toList(), ImmutableList::copyOf);
+  }
+
+  private static  Collector> toImmutableSet() {
+    return collectingAndThen(toList(), ImmutableSet::copyOf);
+  }
+
+  private class DiagnosticAssertions {
+    private final String expectedDiagnostic;
+    private final ImmutableList> diagnostics;
+
+    DiagnosticAssertions(
+        String expectedDiagnostic,
+        Iterable> matchingDiagnostics) {
+      this.expectedDiagnostic = expectedDiagnostic;
+      this.diagnostics = ImmutableList.copyOf(matchingDiagnostics);
+    }
+
+    DiagnosticAssertions(
+        DiagnosticAssertions previous,
+        Iterable> matchingDiagnostics) {
+      this(previous.expectedDiagnostic, matchingDiagnostics);
+    }
+
+    ImmutableList> filterDiagnostics(
+        Predicate> predicate) {
+      return diagnostics.stream().filter(predicate).collect(toImmutableList());
+    }
+
+     Stream mapDiagnostics(Function, T> mapper) {
+      return diagnostics.stream().map(mapper);
+    }
+
+    protected void failExpectingMatchingDiagnostic(String format, Object... args) {
+      failWithoutActual(
+          simpleFact(
+              new StringBuilder("Expected ")
+                  .append(expectedDiagnostic)
+                  .append(String.format(format, args))
+                  .toString()));
+    }
+  }
+
+  /** Assertions that a note, warning, or error was found in a given file. */
+  public final class DiagnosticInFile extends DiagnosticAssertions {
+
+    private DiagnosticInFile(
+        String expectedDiagnostic,
+        Iterable> diagnosticsWithMessage) {
+      super(expectedDiagnostic, diagnosticsWithMessage);
+    }
+
+    /** Asserts that the note, warning, or error was found in a given file. */
+    @CanIgnoreReturnValue
+    public DiagnosticOnLine inFile(JavaFileObject expectedFile) {
+      return new DiagnosticOnLine(this, expectedFile, findDiagnosticsInFile(expectedFile));
+    }
+
+    /** Returns the diagnostics that are in the given file. Fails the test if none are found. */
+    private ImmutableList> findDiagnosticsInFile(
+        JavaFileObject expectedFile) {
+      String expectedFilePath = expectedFile.toUri().getPath();
+      ImmutableList> diagnosticsInFile =
+          filterDiagnostics(
+              diagnostic -> {
+                JavaFileObject source = diagnostic.getSource();
+                return source != null
+                    && requireNonNull(source.toUri().getPath()).equals(expectedFilePath);
+              });
+      if (diagnosticsInFile.isEmpty()) {
+        failExpectingMatchingDiagnostic(
+            " in %s, but found it in %s", expectedFile.getName(), sourceFilesWithDiagnostics());
+      }
+      return diagnosticsInFile;
+    }
+
+    private ImmutableSet sourceFilesWithDiagnostics() {
+      return mapDiagnostics(
+              diagnostic ->
+                  diagnostic.getSource() == null
+                      ? "(no associated file)"
+                      : diagnostic.getSource().getName())
+          .collect(toImmutableSet());
+    }
+  }
+
+  /** An object that can list the lines in a file. */
+  static final class LinesInFile {
+    private final JavaFileObject file;
+    private ImmutableList lines;
+
+    LinesInFile(JavaFileObject file) {
+      this.file = file;
+    }
+
+    String fileName() {
+      return file.getName();
+    }
+
+    /** Returns the lines in the file. */
+    ImmutableList linesInFile() {
+      if (lines == null) {
+        try {
+          lines = JavaFileObjects.asByteSource(file).asCharSource(UTF_8).readLines();
+        } catch (IOException e) {
+          throw new UncheckedIOException(e);
+        }
+      }
+      return lines;
+    }
+
+    /**
+     * Returns a {@link Collector} that lists the file lines numbered by the input stream (1-based).
+     */
+    Collector toLineList() {
+      return Collectors.mapping(this::listLine, joining("\n"));
+    }
+
+    /** Lists the line at a line number (1-based). */
+    String listLine(long lineNumber) {
+      if (lineNumber == Diagnostic.NOPOS) {
+        return "(no associated line)";
+      }
+      checkArgument(lineNumber > 0 && lineNumber <= linesInFile().size(),
+          "Invalid line number %s; number of lines is only %s", lineNumber, linesInFile().size());
+      return String.format("%4d: %s", lineNumber, linesInFile().get((int) (lineNumber - 1)));
+    }
+  }
+
+  /** Assertions that a note, warning, or error was found on a given line. */
+  public final class DiagnosticOnLine extends DiagnosticAssertions {
+
+    private final LinesInFile linesInFile;
+
+    private DiagnosticOnLine(
+        DiagnosticAssertions previous,
+        JavaFileObject file,
+        ImmutableList> diagnosticsInFile) {
+      super(previous, diagnosticsInFile);
+      this.linesInFile = new LinesInFile(file);
+    }
+
+    /** Asserts that the note, warning, or error was found on a given line. */
+    @CanIgnoreReturnValue
+    public DiagnosticAtColumn onLine(long expectedLine) {
+      return new DiagnosticAtColumn(
+          this, linesInFile, expectedLine, findMatchingDiagnosticsOnLine(expectedLine));
+    }
+
+    /**
+     * Asserts that the note, warning, or error was found on the single line that contains a
+     * substring.
+     */
+    public void onLineContaining(String expectedLineSubstring) {
+      findMatchingDiagnosticsOnLine(findLineContainingSubstring(expectedLineSubstring));
+    }
+
+    /**
+     * Returns the single line number that contains an expected substring.
+     *
+     * @throws IllegalArgumentException unless exactly one line in the file contains {@code
+     *     expectedLineSubstring}
+     */
+    private long findLineContainingSubstring(String expectedLineSubstring) {
+      // The explicit type arguments below are needed by our nullness checker.
+      ImmutableSet matchingLines =
+          Streams.mapWithIndex(
+                  linesInFile.linesInFile().stream(),
+                  (line, index) -> line.contains(expectedLineSubstring) ? index : null)
+              .filter(notNull())
+              .map(index -> index + 1) // to 1-based line numbers
+              .collect(toImmutableSet());
+      checkArgument(
+          !matchingLines.isEmpty(),
+          "No line in %s contained \"%s\"",
+          linesInFile.fileName(),
+          expectedLineSubstring);
+      checkArgument(
+          matchingLines.size() == 1,
+          "More than one line in %s contained \"%s\":\n%s",
+          linesInFile.fileName(),
+          expectedLineSubstring,
+          matchingLines.stream().collect(linesInFile.toLineList()));
+      return Iterables.getOnlyElement(matchingLines);
+    }
+
+    /**
+     * Returns the matching diagnostics found on a specific line of the file. Fails the test if none
+     * are found.
+     *
+     * @param expectedLine the expected line number
+     */
+    @CanIgnoreReturnValue
+    private ImmutableList> findMatchingDiagnosticsOnLine(
+        long expectedLine) {
+      ImmutableList> diagnosticsOnLine =
+          filterDiagnostics(diagnostic -> diagnostic.getLineNumber() == expectedLine);
+      if (diagnosticsOnLine.isEmpty()) {
+        failExpectingMatchingDiagnostic(
+            " in %s on line:\n%s\nbut found it on line(s):\n%s",
+            linesInFile.fileName(),
+            linesInFile.listLine(expectedLine),
+            mapDiagnostics(Diagnostic::getLineNumber).collect(linesInFile.toLineList()));
+      }
+      return diagnosticsOnLine;
+    }
+  }
+
+  /** Assertions that a note, warning, or error was found at a given column. */
+  public final class DiagnosticAtColumn extends DiagnosticAssertions {
+
+    private final LinesInFile linesInFile;
+    private final long line;
+
+    private DiagnosticAtColumn(
+        DiagnosticAssertions previous,
+        LinesInFile linesInFile,
+        long line,
+        ImmutableList> diagnosticsOnLine) {
+      super(previous, diagnosticsOnLine);
+      this.linesInFile = linesInFile;
+      this.line = line;
+    }
+
+    /** Asserts that the note, warning, or error was found at a given column. */
+    public void atColumn(final long expectedColumn) {
+      if (filterDiagnostics(diagnostic -> diagnostic.getColumnNumber() == expectedColumn)
+          .isEmpty()) {
+        failExpectingMatchingDiagnostic(
+            " in %s at column %d of line %d, but found it at column(s) %s:\n%s",
+            linesInFile.fileName(),
+            expectedColumn,
+            line,
+            columnsWithDiagnostics(),
+            linesInFile.listLine(line));
+      }
+    }
+
+    private ImmutableSet columnsWithDiagnostics() {
+      return mapDiagnostics(
+              diagnostic ->
+                  diagnostic.getColumnNumber() == Diagnostic.NOPOS
+                      ? "(no associated position)"
+                      : Long.toString(diagnostic.getColumnNumber()))
+          .collect(toImmutableSet());
+    }
+  }
+}
diff --git a/src/main/java/com/google/testing/compile/CompilationSubjectFactory.java b/src/main/java/com/google/testing/compile/CompilationSubjectFactory.java
new file mode 100644
index 00000000..b2ff5ff4
--- /dev/null
+++ b/src/main/java/com/google/testing/compile/CompilationSubjectFactory.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2016 Google, Inc.
+ *
+ * Licensed 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.
+ */
+package com.google.testing.compile;
+
+import com.google.common.truth.FailureMetadata;
+import com.google.common.truth.Subject;
+import com.google.common.truth.Truth;
+import org.jspecify.annotations.Nullable;
+
+/** A {@link Truth} subject factory for a {@link Compilation}. */
+final class CompilationSubjectFactory implements Subject.Factory {
+
+  @Override
+  public CompilationSubject createSubject(
+      FailureMetadata failureMetadata, @Nullable Compilation that) {
+    return new CompilationSubject(failureMetadata, that);
+  }
+}
diff --git a/src/main/java/com/google/testing/compile/CompileTester.java b/src/main/java/com/google/testing/compile/CompileTester.java
index 83891f87..6c74a97a 100644
--- a/src/main/java/com/google/testing/compile/CompileTester.java
+++ b/src/main/java/com/google/testing/compile/CompileTester.java
@@ -15,78 +15,205 @@
  */
 package com.google.testing.compile;
 
+import com.google.common.io.ByteSource;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+
+import java.nio.charset.Charset;
+
 import javax.tools.Diagnostic;
+import javax.tools.JavaFileManager;
 import javax.tools.JavaFileObject;
 
 /**
  * The root of the fluent API for testing the result of compilation.
  *
- * This interface exists only to faciliate a fluent API and is subject to change. Implementing
+ * 
This interface exists only to facilitate a fluent API and is subject to change. Implementing
  * this interface is not recommended.
  *
  * @author Gregory Kick
  */
 public interface CompileTester {
-  /** The clause in the fluent API that tests for successful compilation. */
+  /**
+   * The clause in the fluent API that tests that the code parses equivalently to the specified
+   * code.
+   */
+  void parsesAs(JavaFileObject first, JavaFileObject... rest);
+
+  /** The clause in the fluent API that tests for successful compilation without errors. */
+  @CanIgnoreReturnValue
   SuccessfulCompilationClause compilesWithoutError();
 
+  /**
+   * The clause in the fluent API that tests for successful compilation without warnings or
+   * errors.
+   */
+  @CanIgnoreReturnValue
+  CleanCompilationClause compilesWithoutWarnings();
+
   /** The clause in the fluent API that tests for unsuccessful compilation. */
+  @CanIgnoreReturnValue
   UnsuccessfulCompilationClause failsToCompile();
 
-  /** The clause in the fluent API that allows for chaining test conditions. */
+  /**
+   * The clause in the fluent API that allows for chaining test conditions.
+   *
+   * @param T the clause type returned by {@link #and()}
+   */
   public interface ChainingClause {
     T and();
   }
 
   /**
-   * The clause in the fluent API that checks that an error is associated with a particular
+   * The clause in the fluent API that checks notes in a compilation.
+   *
+   * @param T the non-generic clause type implementing this interface
+   */
+  public interface CompilationWithNotesClause {
+    /**
+     * Checks that a note exists that contains the given fragment in the
+     * {@linkplain Diagnostic#getMessage(java.util.Locale) diagnostic message}.
+     */
+    @CanIgnoreReturnValue
+    FileClause withNoteContaining(String messageFragment);
+
+    /**
+     * Checks that the total note count in all files matches the given amount. This only counts
+     * diagnostics of the kind {@link Diagnostic.Kind#NOTE}.
+     */
+    @CanIgnoreReturnValue
+    T withNoteCount(int noteCount);
+  }
+
+  /**
+   * The clause in the fluent API that checks notes and warnings in a compilation.
+   *
+   * @param T the non-generic clause type implementing this interface
+   */
+  public interface CompilationWithWarningsClause extends CompilationWithNotesClause {
+
+    /**
+     * Checks that a warning exists that contains the given fragment in the
+     * {@linkplain Diagnostic#getMessage(java.util.Locale) diagnostic message}.
+     */
+    @CanIgnoreReturnValue
+    FileClause withWarningContaining(String messageFragment);
+
+    /**
+     * Checks that the total warning count in all files matches the given amount. This only counts
+     * diagnostics of the kind {@link Diagnostic.Kind#WARNING}.
+     */
+    @CanIgnoreReturnValue
+    T withWarningCount(int warningCount);
+  }
+
+  /**
+   * The clause in the fluent API that checks that a diagnostic is associated with a particular
    * {@link JavaFileObject}.
+   *
+   * @param T the clause type returned by {@link ChainingClause#and()}
    */
-  public interface FileClause extends ChainingClause {
-    LineClause in(JavaFileObject file);
+  public interface FileClause extends ChainingClause {
+    @CanIgnoreReturnValue
+    LineClause in(JavaFileObject file);
   }
 
   /**
-   * The clause in the fluent API that checks that an error is on a particular
+   * The clause in the fluent API that checks that a diagnostic is on a particular
    * {@linkplain Diagnostic#getLineNumber() line}.
+   *
+   * @param T the clause type returned by {@link ChainingClause#and()}
    */
-  public interface LineClause extends ChainingClause {
-    ColumnClause onLine(long lineNumber);
+  public interface LineClause extends ChainingClause {
+    @CanIgnoreReturnValue
+    ColumnClause onLine(long lineNumber);
   }
 
   /**
-   * The clause in the fluent API that checks that an error starts at a particular
+   * The clause in the fluent API that checks that a diagnostic starts at a particular
    * {@linkplain Diagnostic#getColumnNumber() column}.
+   *
+   * @param T the clause type returned by {@link ChainingClause#and()}
    */
-  public interface ColumnClause extends ChainingClause {
-    ChainingClause atColumn(long columnNumber);
+  public interface ColumnClause extends ChainingClause {
+    @CanIgnoreReturnValue
+    ChainingClause atColumn(long columnNumber);
   }
 
-  /** The clause in the fluent API that checks that files were generated. */
-  public interface GeneratedPredicateClause {
+  /**
+   * The clause in the fluent API that checks that files were generated.
+   *
+   * @param T the non-generic clause type implementing this interface
+   */
+  public interface GeneratedPredicateClause {
     /**
      * Checks that a source file with an equivalent
      * AST was generated for each of
      * the given {@linkplain JavaFileObject files}.
      */
-    SuccessfulCompilationClause generatesSources(JavaFileObject first, JavaFileObject... rest);
+    @CanIgnoreReturnValue
+    T generatesSources(JavaFileObject first, JavaFileObject... rest);
 
     /**
-     * Checks that a file with equivalent path and content was generated for each of the given
+     * Checks that a file with equivalent kind and content was generated for each of the given
      * {@linkplain JavaFileObject files}.
      */
-    SuccessfulCompilationClause generatesFiles(JavaFileObject first, JavaFileObject... rest);
+    @CanIgnoreReturnValue
+    T generatesFiles(JavaFileObject first, JavaFileObject... rest);
+
+    /**
+     * Checks that a file with the specified location, package, and filename was generated.
+     */
+    @CanIgnoreReturnValue
+    SuccessfulFileClause generatesFileNamed(
+        JavaFileManager.Location location, String packageName, String relativeName);
+  }
+
+  /**
+   * The clause in the fluent API that checks that a generated file has the specified contents.
+   *
+   * @param T the non-generic clause type implementing this interface
+   */
+  public interface SuccessfulFileClause extends ChainingClause> {
+    /**
+     * Checks that the contents of the generated file match the contents of the specified
+     * {@link ByteSource}.
+     */
+    @CanIgnoreReturnValue
+    SuccessfulFileClause withContents(ByteSource expectedByteSource);
+
+    /**
+     * Checks that the contents of the generated file are equal to the specified string in the given
+     * charset.
+     */
+    @CanIgnoreReturnValue
+    SuccessfulFileClause withStringContents(Charset charset, String expectedString);
   }
 
   /** The clause in the fluent API for further tests on successful compilations. */
-  public interface SuccessfulCompilationClause extends ChainingClause {}
+  public interface SuccessfulCompilationClause
+      extends CompilationWithWarningsClause,
+          ChainingClause> {}
+
+  /** The clause in the fluent API for further tests on successful compilations without warnings. */
+  public interface CleanCompilationClause
+      extends CompilationWithNotesClause,
+          ChainingClause> {}
 
   /** The clause in the fluent API for further tests on unsuccessful compilations. */
-  public interface UnsuccessfulCompilationClause {
+  public interface UnsuccessfulCompilationClause
+      extends CompilationWithWarningsClause {
     /**
      * Checks that an error exists that contains the given fragment in the
      * {@linkplain Diagnostic#getMessage(java.util.Locale) diagnostic message}.
      */
-    FileClause withErrorContaining(String messageFragment);
+    @CanIgnoreReturnValue
+    FileClause withErrorContaining(String messageFragment);
+
+    /**
+     * Checks that the total error count in all files matches the given amount. This only counts
+     * diagnostics of the kind {@link Diagnostic.Kind#ERROR} and not (for example) warnings.
+     */
+    @CanIgnoreReturnValue
+    UnsuccessfulCompilationClause withErrorCount(int errorCount);
   }
 }
diff --git a/src/main/java/com/google/testing/compile/Compiler.java b/src/main/java/com/google/testing/compile/Compiler.java
new file mode 100644
index 00000000..827f2912
--- /dev/null
+++ b/src/main/java/com/google/testing/compile/Compiler.java
@@ -0,0 +1,302 @@
+/*
+ * Copyright (C) 2016 Google, Inc.
+ *
+ * Licensed 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.
+ */
+package com.google.testing.compile;
+
+import static com.google.common.base.Functions.toStringFunction;
+import static com.google.common.collect.ImmutableList.toImmutableList;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static javax.tools.ToolProvider.getSystemJavaCompiler;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Splitter;
+import com.google.common.base.StandardSystemProperty;
+import com.google.common.collect.FluentIterable;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.testing.compile.Compilation.Status;
+import java.io.File;
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.LinkedHashSet;
+import java.util.Locale;
+import java.util.Optional;
+import java.util.Set;
+import javax.annotation.processing.Processor;
+import javax.tools.DiagnosticCollector;
+import javax.tools.JavaCompiler;
+import javax.tools.JavaCompiler.CompilationTask;
+import javax.tools.JavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.StandardLocation;
+import org.jspecify.annotations.Nullable;
+
+/** An object that can {@link #compile} Java source files. */
+@AutoValue
+// clashes with java.lang.Compiler (which is deprecated for removal in 9)
+@SuppressWarnings("JavaLangClash")
+public abstract class Compiler {
+
+  /** Returns the {@code javac} compiler. */
+  public static Compiler javac() {
+    return compiler(getSystemJavaCompiler());
+  }
+
+  /** Returns a {@link Compiler} that uses a given {@link JavaCompiler} instance. */
+  public static Compiler compiler(JavaCompiler javaCompiler) {
+    return new AutoValue_Compiler(
+        javaCompiler, ImmutableList.of(), ImmutableList.of(), Optional.empty(), Optional.empty());
+  }
+
+  abstract JavaCompiler javaCompiler();
+
+  /** The annotation processors applied during compilation. */
+  public abstract ImmutableList processors();
+
+  /** The options passed to the compiler. */
+  public abstract ImmutableList options();
+
+  /** The compilation class path. If not present, the system class path is used. */
+  public abstract Optional> classPath();
+
+  /**
+   * The annotation processor path. If not present, the system annotation processor path is used.
+   */
+  public abstract Optional> annotationProcessorPath();
+
+  /**
+   * Uses annotation processors during compilation. These replace any previously specified.
+   *
+   * 
Note that most annotation processors cannot be reused for more than one compilation.
+   *
+   * @return a new instance with the same options and the given processors
+   */
+  public final Compiler withProcessors(Processor... processors) {
+    return withProcessors(ImmutableList.copyOf(processors));
+  }
+
+  /**
+   * Uses annotation processors during compilation. These replace any previously specified.
+   *
+   * 
Note that most annotation processors cannot be reused for more than one compilation.
+   *
+   * @return a new instance with the same options and the given processors
+   */
+  public final Compiler withProcessors(Iterable processors) {
+    return copy(
+        ImmutableList.copyOf(processors), options(), classPath(), annotationProcessorPath());
+  }
+
+  /**
+   * Passes command-line options to the compiler. These replace any previously specified.
+   *
+   * @return a new instance with the same processors and the given options
+   */
+  public final Compiler withOptions(Object... options) {
+    return withOptions(ImmutableList.copyOf(options));
+  }
+
+  /**
+   * Passes command-line options to the compiler. These replace any previously specified.
+   *
+   * @return a new instance with the same processors and the given options
+   */
+  public final Compiler withOptions(Iterable options) {
+    return copy(
+        processors(),
+        FluentIterable.from(options).transform(toStringFunction()).toList(),
+        classPath(),
+        annotationProcessorPath());
+  }
+
+  /**
+   * Uses the classpath from the passed on classloader (and its parents) for the compilation instead
+   * of the system classpath.
+   *
+   * @throws IllegalArgumentException if the given classloader had classpaths which we could not
+   *     determine or use for compilation.
+   * @deprecated prefer {@link #withClasspath(Iterable)}. This method only supports {@link
+   *     URLClassLoader} and the default system classloader, and {@link File}s are usually a more
+   *     natural way to expression compilation classpaths than class loaders.
+   */
+  @Deprecated
+  public final Compiler withClasspathFrom(ClassLoader classloader) {
+    return copy(
+        processors(),
+        options(),
+        Optional.of(getClasspathFromClassloader(classloader)),
+        annotationProcessorPath());
+  }
+
+  /** Uses the given classpath for the compilation instead of the system classpath. */
+  public final Compiler withClasspath(Iterable classPath) {
+    return copy(
+        processors(),
+        options(),
+        Optional.of(ImmutableList.copyOf(classPath)),
+        annotationProcessorPath());
+  }
+
+  /**
+   * Uses the given annotation processor path for the compilation instead of the system annotation
+   * processor path.
+   */
+  public final Compiler withAnnotationProcessorPath(Iterable annotationProcessorPath) {
+    return copy(
+        processors(),
+        options(),
+        classPath(),
+        Optional.of(ImmutableList.copyOf(annotationProcessorPath)));
+  }
+
+  /**
+   * Compiles Java source files.
+   *
+   * @return the results of the compilation
+   */
+  public final Compilation compile(JavaFileObject... files) {
+    return compile(ImmutableList.copyOf(files));
+  }
+
+  /**
+   * Compiles Java source files.
+   *
+   * @return the results of the compilation
+   */
+  public final Compilation compile(Iterable files) {
+    DiagnosticCollector diagnosticCollector = new DiagnosticCollector<>();
+    try (StandardJavaFileManager standardFileManager = standardFileManager(diagnosticCollector);
+        InMemoryJavaFileManager fileManager = new InMemoryJavaFileManager(standardFileManager)) {
+      fileManager.addSourceFiles(files);
+      classPath().ifPresent(path -> setLocation(fileManager, StandardLocation.CLASS_PATH, path));
+      annotationProcessorPath()
+          .ifPresent(
+              path -> setLocation(fileManager, StandardLocation.ANNOTATION_PROCESSOR_PATH, path));
+
+      CompilationTask task =
+          javaCompiler()
+              .getTask(
+                  null, // use the default because old versions of javac log some output on stderr
+                  fileManager,
+                  diagnosticCollector,
+                  options(),
+                  ImmutableSet.of(),
+                  files);
+      task.setProcessors(processors());
+      boolean succeeded = task.call();
+      Compilation compilation =
+          new Compilation(
+              this,
+              files,
+              succeeded,
+              diagnosticCollector.getDiagnostics(),
+              fileManager.getOutputFiles());
+      if (compilation.status().equals(Status.FAILURE) && compilation.errors().isEmpty()) {
+        throw new CompilationFailureException(compilation);
+      }
+      return compilation;
+    } catch (IOException e) {
+      throw new UncheckedIOException(e);
+    }
+  }
+
+  private StandardJavaFileManager standardFileManager(
+      DiagnosticCollector diagnosticCollector) {
+    return javaCompiler().getStandardFileManager(diagnosticCollector, Locale.getDefault(), UTF_8);
+  }
+
+  @VisibleForTesting
+  static final @Nullable ClassLoader platformClassLoader = getPlatformClassLoader();
+
+  private static @Nullable ClassLoader getPlatformClassLoader() {
+    try {
+      // JDK >= 9
+      return (ClassLoader) ClassLoader.class.getMethod("getPlatformClassLoader").invoke(null);
+    } catch (ReflectiveOperationException e) {
+      // Java <= 8
+      return null;
+    }
+  }
+
+  /**
+   * Returns the current classpaths of the given classloader including its parents.
+   *
+   * @throws IllegalArgumentException if the given classloader had classpaths which we could not
+   *     determine or use for compilation.
+   */
+  private static ImmutableList getClasspathFromClassloader(ClassLoader classloader) {
+    ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
+
+    // Concatenate search paths from all classloaders in the hierarchy 'till the system classloader.
+    Set classpaths = new LinkedHashSet<>();
+    for (ClassLoader currentClassloader = classloader;
+        ;
+        currentClassloader = currentClassloader.getParent()) {
+      if (currentClassloader == systemClassLoader) {
+        Iterables.addAll(
+            classpaths,
+            Splitter.on(StandardSystemProperty.PATH_SEPARATOR.value())
+                .split(StandardSystemProperty.JAVA_CLASS_PATH.value()));
+        break;
+      }
+      if (currentClassloader == platformClassLoader) {
+        break;
+      }
+      if (currentClassloader instanceof URLClassLoader) {
+        // We only know how to extract classpaths from URLClassloaders.
+        for (URL url : ((URLClassLoader) currentClassloader).getURLs()) {
+          if (url.getProtocol().equals("file")) {
+            classpaths.add(url.getPath());
+          } else {
+            throw new IllegalArgumentException(
+                "Given classloader consists of classpaths which are "
+                    + "unsupported for compilation.");
+          }
+        }
+      } else {
+        throw new IllegalArgumentException(
+            String.format(
+                "Classpath for compilation could not be extracted "
+                    + "since %s is not an instance of URLClassloader",
+                currentClassloader));
+      }
+    }
+
+    return classpaths.stream().map(File::new).collect(toImmutableList());
+  }
+
+  private static void setLocation(
+      InMemoryJavaFileManager fileManager, StandardLocation location, ImmutableList path) {
+    try {
+      fileManager.setLocation(location, path);
+    } catch (IOException e) {
+      // impossible by specification
+      throw new UncheckedIOException(e);
+    }
+  }
+
+  private Compiler copy(
+      ImmutableList processors,
+      ImmutableList options,
+      Optional> classPath,
+      Optional> annotationProcessorPath) {
+    return new AutoValue_Compiler(
+        javaCompiler(), processors, options, classPath, annotationProcessorPath);
+  }
+}
diff --git a/src/main/java/com/google/testing/compile/Diagnostics.java b/src/main/java/com/google/testing/compile/Diagnostics.java
deleted file mode 100644
index 5fc2c923..00000000
--- a/src/main/java/com/google/testing/compile/Diagnostics.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (C) 2013 Google, Inc.
- *
- * Licensed 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.
- */
-package com.google.testing.compile;
-
-import javax.tools.Diagnostic;
-
-/**
- * Utilities for working with {@link Diagnostic} instances and collections thereof.
- *
- * @author Gregory Kick
- */
-final class Diagnostics {
-  private Diagnostics() {}
-
-  /**
-   * Returns {@code diagnostics} as a {@link String} similar to the error output printed by
-   * {@code javac}.
-   */
-  static String toString(Iterable> diagnostics) {
-    StringBuilder builder = new StringBuilder();
-    for (Diagnostic diagnostic : diagnostics) {
-      builder.append(diagnostic.toString()).append('\n');
-    }
-    return builder.toString();
-  }
-}
diff --git a/src/main/java/com/google/testing/compile/EqualityScanner.java b/src/main/java/com/google/testing/compile/EqualityScanner.java
deleted file mode 100644
index a6e6c764..00000000
--- a/src/main/java/com/google/testing/compile/EqualityScanner.java
+++ /dev/null
@@ -1,514 +0,0 @@
-/*
- * Copyright (C) 2013 Google, Inc.
- *
- * Licensed 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.
- */
-package com.google.testing.compile;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.util.Iterator;
-
-import javax.annotation.Nullable;
-
-import com.google.common.base.Objects;
-import com.google.common.base.Optional;
-import com.sun.source.tree.AnnotationTree;
-import com.sun.source.tree.ArrayAccessTree;
-import com.sun.source.tree.ArrayTypeTree;
-import com.sun.source.tree.AssertTree;
-import com.sun.source.tree.AssignmentTree;
-import com.sun.source.tree.BinaryTree;
-import com.sun.source.tree.BlockTree;
-import com.sun.source.tree.BreakTree;
-import com.sun.source.tree.CaseTree;
-import com.sun.source.tree.CatchTree;
-import com.sun.source.tree.ClassTree;
-import com.sun.source.tree.CompilationUnitTree;
-import com.sun.source.tree.CompoundAssignmentTree;
-import com.sun.source.tree.ConditionalExpressionTree;
-import com.sun.source.tree.ContinueTree;
-import com.sun.source.tree.DoWhileLoopTree;
-import com.sun.source.tree.EmptyStatementTree;
-import com.sun.source.tree.EnhancedForLoopTree;
-import com.sun.source.tree.ErroneousTree;
-import com.sun.source.tree.ExpressionStatementTree;
-import com.sun.source.tree.ForLoopTree;
-import com.sun.source.tree.IdentifierTree;
-import com.sun.source.tree.IfTree;
-import com.sun.source.tree.ImportTree;
-import com.sun.source.tree.InstanceOfTree;
-import com.sun.source.tree.LabeledStatementTree;
-import com.sun.source.tree.LiteralTree;
-import com.sun.source.tree.MemberSelectTree;
-import com.sun.source.tree.MethodInvocationTree;
-import com.sun.source.tree.MethodTree;
-import com.sun.source.tree.ModifiersTree;
-import com.sun.source.tree.NewArrayTree;
-import com.sun.source.tree.NewClassTree;
-import com.sun.source.tree.ParameterizedTypeTree;
-import com.sun.source.tree.ParenthesizedTree;
-import com.sun.source.tree.PrimitiveTypeTree;
-import com.sun.source.tree.ReturnTree;
-import com.sun.source.tree.SwitchTree;
-import com.sun.source.tree.SynchronizedTree;
-import com.sun.source.tree.ThrowTree;
-import com.sun.source.tree.Tree;
-import com.sun.source.tree.Tree.Kind;
-import com.sun.source.tree.TryTree;
-import com.sun.source.tree.TypeCastTree;
-import com.sun.source.tree.TypeParameterTree;
-import com.sun.source.tree.UnaryTree;
-import com.sun.source.tree.VariableTree;
-import com.sun.source.tree.WhileLoopTree;
-import com.sun.source.tree.WildcardTree;
-import com.sun.source.util.SimpleTreeVisitor;
-
-/**
- * A visitor that traverses a {@link Tree} in parallel with its argument to check that the trees are
- * the same.  Returns {@code true} if the trees are the same, otherwise {@code false}.
- *
- * @author Gregory Kick
- */
-/*
- * This should really just implement TreeVisitor this insulates against API changes in different
- * versions of Java.
- */
-@SuppressWarnings("restriction") // Sun APIs usage intended
-final class EqualityScanner extends SimpleTreeVisitor {
-  private  Optional checkTypeAndCast(T reference, Tree tree) {
-    Kind referenceKind = checkNotNull(reference).getKind();
-    Kind treeKind = checkNotNull(tree).getKind();
-    if (referenceKind == treeKind) {
-      @SuppressWarnings("unchecked") // checked by Kind
-      T treeAsReferenceType = (T) tree;
-      return Optional.of(treeAsReferenceType);
-    } else {
-      return Optional.absent();
-    }
-  }
-
-  private boolean scan(@Nullable Tree reference, @Nullable Tree tree) {
-    return (reference == null) ? (tree == null) : reference.accept(this, tree);
-  }
-
-  private boolean parallelScan(Iterable reference,
-      Iterable trees) {
-    if (reference == null && trees == null) {
-      return true;
-    } else if (reference != null && trees != null ) {
-      Iterator referenceIterator = reference.iterator();
-      Iterator treesIterator = trees.iterator();
-      while (referenceIterator.hasNext() && treesIterator.hasNext()) {
-        if (!referenceIterator.next().accept(this, treesIterator.next())) {
-          return false;
-        }
-      }
-      return (referenceIterator.hasNext() == treesIterator.hasNext());
-    } else {
-      return false;
-    }
-  }
-
-  @Override
-  public Boolean visitAnnotation(AnnotationTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getAnnotationType(), other.get().getAnnotationType())
-        && parallelScan(reference.getArguments(), other.get().getArguments());
-  }
-
-  @Override
-  public Boolean visitMethodInvocation(MethodInvocationTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && parallelScan(reference.getTypeArguments(), other.get().getTypeArguments())
-        && scan(reference.getMethodSelect(), other.get().getMethodSelect())
-        && parallelScan(reference.getArguments(), other.get().getArguments());
-  }
-
-  @Override
-  public Boolean visitAssert(AssertTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getCondition(), other.get().getCondition())
-        && scan(reference.getDetail(), other.get().getDetail());
-  }
-
-  @Override
-  public Boolean visitAssignment(AssignmentTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getVariable(), other.get().getVariable())
-        && scan(reference.getExpression(), other.get().getExpression());
-  }
-
-  @Override
-  public Boolean visitCompoundAssignment(CompoundAssignmentTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getVariable(), other.get().getVariable())
-        && scan(reference.getExpression(), other.get().getExpression());
-  }
-
-  @Override
-  public Boolean visitBinary(BinaryTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getLeftOperand(), other.get().getLeftOperand())
-        && scan(reference.getRightOperand(), other.get().getRightOperand());
-  }
-
-  @Override
-  public Boolean visitBlock(BlockTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && (reference.isStatic() == other.get().isStatic())
-        && parallelScan(reference.getStatements(), other.get().getStatements());
-  }
-
-  @Override
-  public Boolean visitBreak(BreakTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent() && reference.getLabel().contentEquals(other.get().getLabel());
-  }
-
-  @Override
-  public Boolean visitCase(CaseTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getExpression(), other.get().getExpression())
-        && parallelScan(reference.getStatements(), other.get().getStatements());
-  }
-
-  @Override
-  public Boolean visitCatch(CatchTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getParameter(), other.get().getParameter())
-        && scan(reference.getBlock(), other.get().getBlock());
-  }
-
-  @Override
-  public Boolean visitClass(ClassTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getModifiers(), other.get().getModifiers())
-        && reference.getSimpleName().contentEquals(other.get().getSimpleName())
-        && parallelScan(reference.getTypeParameters(), other.get().getTypeParameters())
-        && scan(reference.getExtendsClause(), other.get().getExtendsClause())
-        && parallelScan(reference.getImplementsClause(), other.get().getImplementsClause())
-        && parallelScan(reference.getMembers(), other.get().getMembers());
-  }
-
-  @Override
-  public Boolean visitConditionalExpression(ConditionalExpressionTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getCondition(), other.get().getCondition())
-        && scan(reference.getTrueExpression(), other.get().getTrueExpression())
-        && scan(reference.getFalseExpression(), other.get().getFalseExpression());
-  }
-
-  @Override
-  public Boolean visitContinue(ContinueTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && reference.getLabel().contentEquals(other.get().getLabel());
-  }
-
-  @Override
-  public Boolean visitDoWhileLoop(DoWhileLoopTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getCondition(), other.get().getCondition())
-        && scan(reference.getStatement(), other.get().getStatement());
-  }
-
-  @Override
-  public Boolean visitErroneous(ErroneousTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && parallelScan(reference.getErrorTrees(), other.get().getErrorTrees());
-  }
-
-  @Override
-  public Boolean visitExpressionStatement(ExpressionStatementTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getExpression(), other.get().getExpression());
-  }
-
-  @Override
-  public Boolean visitEnhancedForLoop(EnhancedForLoopTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getVariable(), other.get().getVariable())
-        && scan(reference.getExpression(), other.get().getExpression())
-        && scan(reference.getStatement(), other.get().getStatement());
-  }
-
-  @Override
-  public Boolean visitForLoop(ForLoopTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && parallelScan(reference.getInitializer(), other.get().getInitializer())
-        && scan(reference.getCondition(), other.get().getCondition())
-        && parallelScan(reference.getUpdate(), other.get().getUpdate())
-        && scan(reference.getStatement(), other.get().getStatement());
-
-  }
-
-  @Override
-  public Boolean visitIdentifier(IdentifierTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && reference.getName().contentEquals(other.get().getName());
-  }
-
-  @Override
-  public Boolean visitIf(IfTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getCondition(), other.get().getCondition())
-        && scan(reference.getThenStatement(), other.get().getThenStatement())
-        && scan(reference.getElseStatement(), other.get().getElseStatement());
-  }
-
-  @Override
-  public Boolean visitImport(ImportTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && (reference.isStatic() == other.get().isStatic())
-        && scan(reference.getQualifiedIdentifier(), other.get().getQualifiedIdentifier());
-  }
-
-  @Override
-  public Boolean visitArrayAccess(ArrayAccessTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getExpression(), other.get().getExpression())
-        && scan(reference.getIndex(), other.get().getIndex());
-  }
-
-  @Override
-  public Boolean visitLabeledStatement(LabeledStatementTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && reference.getLabel().contentEquals(other.get().getLabel())
-        && scan(reference.getStatement(), other.get().getStatement());
-  }
-
-  @Override
-  public Boolean visitLiteral(LiteralTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && Objects.equal(reference.getValue(), other.get().getValue());
-  }
-
-  @Override
-  public Boolean visitMethod(MethodTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getModifiers(), other.get().getModifiers())
-        && reference.getName().contentEquals(other.get().getName())
-        && scan(reference.getReturnType(), other.get().getReturnType())
-        && parallelScan(reference.getTypeParameters(), other.get().getTypeParameters())
-        && parallelScan(reference.getParameters(), other.get().getParameters())
-        && parallelScan(reference.getThrows(), other.get().getThrows())
-        && scan(reference.getBody(), other.get().getBody())
-        && scan(reference.getDefaultValue(), other.get().getDefaultValue());
-  }
-
-  @Override
-  public Boolean visitModifiers(ModifiersTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && reference.getFlags().equals(other.get().getFlags())
-        && parallelScan(reference.getAnnotations(), other.get().getAnnotations());
-  }
-
-  @Override
-  public Boolean visitNewArray(NewArrayTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getType(), other.get().getType())
-        && parallelScan(reference.getDimensions(), other.get().getDimensions())
-        && parallelScan(reference.getInitializers(), other.get().getInitializers());
-  }
-
-  @Override
-  public Boolean visitNewClass(NewClassTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getEnclosingExpression(), other.get().getEnclosingExpression())
-        && parallelScan(reference.getTypeArguments(), other.get().getTypeArguments())
-        && scan(reference.getIdentifier(), other.get().getIdentifier())
-        && parallelScan(reference.getArguments(), other.get().getArguments())
-        && scan(reference.getClassBody(), other.get().getClassBody());
-  }
-
-  @Override
-  public Boolean visitParenthesized(ParenthesizedTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getExpression(), other.get().getExpression());
-  }
-
-  @Override
-  public Boolean visitReturn(ReturnTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getExpression(), other.get().getExpression());
-  }
-
-  @Override
-  public Boolean visitMemberSelect(MemberSelectTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getExpression(), other.get().getExpression())
-        && reference.getIdentifier().contentEquals(other.get().getIdentifier());
-  }
-
-  @Override
-  public Boolean visitEmptyStatement(EmptyStatementTree reference, Tree tree) {
-    return checkTypeAndCast(reference, tree).isPresent();
-  }
-
-  @Override
-  public Boolean visitSwitch(SwitchTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getExpression(), other.get().getExpression())
-        && parallelScan(reference.getCases(), other.get().getCases());
-  }
-
-  @Override
-  public Boolean visitSynchronized(SynchronizedTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getExpression(), other.get().getExpression())
-        && scan(reference.getBlock(), other.get().getBlock());
-  }
-
-  @Override
-  public Boolean visitThrow(ThrowTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getExpression(), other.get().getExpression());
-  }
-
-  @Override
-  public Boolean visitCompilationUnit(CompilationUnitTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && parallelScan(reference.getPackageAnnotations(), other.get().getPackageAnnotations())
-        && scan(reference.getPackageName(), other.get().getPackageName())
-        && parallelScan(reference.getImports(), other.get().getImports())
-        && parallelScan(reference.getTypeDecls(), other.get().getTypeDecls());
-    // specifically don't check the JavaFileObject.  Those are supposed to be different.
-    // LineMap is irrelevant
-  }
-
-  @Override
-  public Boolean visitTry(TryTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getBlock(), other.get().getBlock())
-        && parallelScan(reference.getCatches(), other.get().getCatches())
-        && scan(reference.getFinallyBlock(), other.get().getFinallyBlock());
-  }
-
-  @Override
-  public Boolean visitParameterizedType(ParameterizedTypeTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getType(), other.get().getType())
-        && parallelScan(reference.getTypeArguments(), other.get().getTypeArguments());
-  }
-
-  @Override
-  public Boolean visitArrayType(ArrayTypeTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getType(), other.get().getType());
-  }
-
-  @Override
-  public Boolean visitTypeCast(TypeCastTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getType(), other.get().getType())
-        && scan(reference.getExpression(), other.get().getExpression());
-  }
-
-  @Override
-  public Boolean visitPrimitiveType(PrimitiveTypeTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && (reference.getPrimitiveTypeKind() == other.get().getPrimitiveTypeKind());
-  }
-
-  @Override
-  public Boolean visitTypeParameter(TypeParameterTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && reference.getName().contentEquals(other.get().getName())
-        && parallelScan(reference.getBounds(), other.get().getBounds());
-  }
-
-  @Override
-  public Boolean visitInstanceOf(InstanceOfTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getExpression(), other.get().getExpression())
-        && scan(reference.getType(), other.get().getType());
-  }
-
-  @Override
-  public Boolean visitUnary(UnaryTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getExpression(), other.get().getExpression());
-  }
-
-  @Override
-  public Boolean visitVariable(VariableTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getModifiers(), other.get().getModifiers())
-        && reference.getName().contentEquals(other.get().getName())
-        && scan(reference.getType(), other.get().getType())
-        && scan(reference.getInitializer(), other.get().getInitializer());
-  }
-
-  @Override
-  public Boolean visitWhileLoop(WhileLoopTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getCondition(), other.get().getCondition())
-        && scan(reference.getStatement(), other.get().getStatement());
-  }
-
-  @Override
-  public Boolean visitWildcard(WildcardTree reference, Tree tree) {
-    Optional other = checkTypeAndCast(reference, tree);
-    return other.isPresent()
-        && scan(reference.getBound(), other.get().getBound());
-  }
-
-  @Override
-  public Boolean visitOther(Tree reference, Tree tree) {
-    throw new UnsupportedOperationException("cannot compare unknown trees");
-  }
-}
diff --git a/src/main/java/com/google/testing/compile/ForwardingStandardJavaFileManager.java b/src/main/java/com/google/testing/compile/ForwardingStandardJavaFileManager.java
new file mode 100644
index 00000000..9b612b9f
--- /dev/null
+++ b/src/main/java/com/google/testing/compile/ForwardingStandardJavaFileManager.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2018 Google, Inc.
+ *
+ * Licensed 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.
+ */
+
+package com.google.testing.compile;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.nio.file.Path;
+import java.util.Collection;
+import javax.tools.ForwardingJavaFileManager;
+import javax.tools.JavaFileManager.Location;
+import javax.tools.JavaFileObject;
+import javax.tools.StandardJavaFileManager;
+
+/**
+ * Forwards calls to a given {@link StandardJavaFileManager}. Subclasses of this class might
+ * override some of these methods and might also provide additional fields and methods.
+ */
+public class ForwardingStandardJavaFileManager
+    extends ForwardingJavaFileManager implements StandardJavaFileManager {
+
+  /**
+   * Creates a new instance of ForwardingStandardJavaFileManager.
+   *
+   * @param fileManager delegate to this file manager
+   */
+  protected ForwardingStandardJavaFileManager(StandardJavaFileManager fileManager) {
+    super(fileManager);
+  }
+
+  @Override
+  public Iterable getJavaFileObjectsFromFiles(
+      Iterable files) {
+    return fileManager.getJavaFileObjectsFromFiles(files);
+  }
+
+  @Override
+  public Iterable getJavaFileObjects(File... files) {
+    return fileManager.getJavaFileObjects(files);
+  }
+
+  @Override
+  public Iterable getJavaFileObjects(String... names) {
+    return fileManager.getJavaFileObjects(names);
+  }
+
+  @Override
+  public Iterable getJavaFileObjectsFromStrings(Iterable names) {
+    return fileManager.getJavaFileObjectsFromStrings(names);
+  }
+
+  @Override
+  public void setLocation(Location location, Iterable path) throws IOException {
+    fileManager.setLocation(location, path);
+  }
+
+  @Override
+  public Iterable getLocation(Location location) {
+    return fileManager.getLocation(location);
+  }
+
+  // @Override for JDK 9 only
+  public void setLocationFromPaths(Location location, Collection searchpath)
+      throws IOException {
+    Method setLocationFromPaths;
+    try {
+      setLocationFromPaths =
+          fileManager
+              .getClass()
+              .getMethod("setLocationFromPaths", Location.class, Collection.class);
+    } catch (ReflectiveOperationException e) {
+      // JDK < 9
+      return;
+    }
+    try {
+      setLocationFromPaths.invoke(fileManager, location, searchpath);
+    } catch (ReflectiveOperationException e) {
+      throw new LinkageError(e.getMessage(), e);
+    }
+  }
+}
diff --git a/src/main/java/com/google/testing/compile/InMemoryJavaFileManager.java b/src/main/java/com/google/testing/compile/InMemoryJavaFileManager.java
index bb606ff4..b2641b3a 100644
--- a/src/main/java/com/google/testing/compile/InMemoryJavaFileManager.java
+++ b/src/main/java/com/google/testing/compile/InMemoryJavaFileManager.java
@@ -15,6 +15,15 @@
  */
 package com.google.testing.compile;
 
+import static com.google.common.collect.MoreCollectors.toOptional;
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+import com.google.common.collect.ImmutableList;
+import com.google.common.io.ByteSource;
 import java.io.ByteArrayOutputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
@@ -25,24 +34,16 @@
 import java.io.Writer;
 import java.net.URI;
 import java.nio.charset.Charset;
-import java.util.Map.Entry;
-
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
 import javax.tools.FileObject;
-import javax.tools.ForwardingJavaFileManager;
-import javax.tools.JavaFileManager;
 import javax.tools.JavaFileObject;
 import javax.tools.JavaFileObject.Kind;
 import javax.tools.SimpleJavaFileObject;
+import javax.tools.StandardJavaFileManager;
 import javax.tools.StandardLocation;
-
-import com.google.common.base.CharMatcher;
-import com.google.common.base.Objects;
-import com.google.common.base.Optional;
-import com.google.common.cache.CacheBuilder;
-import com.google.common.cache.CacheLoader;
-import com.google.common.cache.LoadingCache;
-import com.google.common.collect.ImmutableList;
-import com.google.common.io.ByteSource;
+import org.jspecify.annotations.Nullable;
 
 /**
  * A file manager implementation that stores all output in memory.
@@ -50,83 +51,109 @@
  * @author Gregory Kick
  */
 // TODO(gak): under java 1.7 this could all be done with a PathFileManager
-final class InMemoryJavaFileManager extends ForwardingJavaFileManager {
-  private final LoadingCache inMemoryFileObjects =
-      CacheBuilder.newBuilder().build(new CacheLoader() {
-        @Override
-        public JavaFileObject load(URI key) {
-          return new InMemoryJavaFileObject(key);
-        }
-      });
+final class InMemoryJavaFileManager extends ForwardingStandardJavaFileManager {
+  private final LoadingCache inMemoryOutputs =
+      CacheBuilder.newBuilder()
+          .build(
+              new CacheLoader() {
+                @Override
+                public JavaFileObject load(URI key) {
+                  return new InMemoryJavaFileObject(key);
+                }
+              });
 
-  InMemoryJavaFileManager(JavaFileManager fileManager) {
+  private final Map inMemoryInputs = new HashMap<>();
+
+  InMemoryJavaFileManager(StandardJavaFileManager fileManager) {
     super(fileManager);
   }
 
   private static URI uriForFileObject(Location location, String packageName, String relativeName) {
-    return URI.create(
-        "mem:///" + location.getName() + '/' + CharMatcher.is('.').replaceFrom(packageName, '/')
-            + '/' + relativeName);
+    StringBuilder uri = new StringBuilder("mem:///").append(location.getName()).append('/');
+    if (!packageName.isEmpty()) {
+      uri.append(packageName.replace('.', '/')).append('/');
+    }
+    uri.append(relativeName);
+    return URI.create(uri.toString());
   }
 
   private static URI uriForJavaFileObject(Location location, String className, Kind kind) {
     return URI.create(
-        "mem:///" + location.getName() + '/' + CharMatcher.is('.').replaceFrom(className, '/')
-            + kind.extension);
+        "mem:///" + location.getName() + '/' + className.replace('.', '/') + kind.extension);
   }
 
   @Override
   public boolean isSameFile(FileObject a, FileObject b) {
-    if (a instanceof InMemoryJavaFileObject) {
-      if (b instanceof InMemoryJavaFileObject) {
-        return ((InMemoryJavaFileObject) a).toUri().equals(((InMemoryJavaFileObject) b).toUri());
-      }
-    }
-    if (b instanceof InMemoryJavaFileObject) {
-      return false;
-    }
-    return super.isSameFile(a, b);
+    /* This check is less strict than what is typically done by the normal compiler file managers
+     * (e.g. JavacFileManager), but is actually the moral equivalent of what most of the
+     * implementations do anyway. We use this check rather than just delegating to the compiler's
+     * file manager because file objects for tests generally cause IllegalArgumentExceptions. */
+    return a.toUri().equals(b.toUri());
   }
 
   @Override
-  public FileObject getFileForInput(Location location, String packageName,
-      String relativeName) throws IOException {
+  public @Nullable FileObject getFileForInput(
+      Location location, String packageName, String relativeName) throws IOException {
     if (location.isOutputLocation()) {
-      return inMemoryFileObjects.getIfPresent(
-          uriForFileObject(location, packageName, relativeName));
-    } else {
-      return super.getFileForInput(location, packageName, relativeName);
+      return inMemoryOutputs.getIfPresent(uriForFileObject(location, packageName, relativeName));
     }
+    Optional inMemoryInput = findInMemoryInput(packageName, relativeName);
+    if (inMemoryInput.isPresent()) {
+      return inMemoryInput.get();
+    }
+    return super.getFileForInput(location, packageName, relativeName);
   }
 
   @Override
-  public JavaFileObject getJavaFileForInput(Location location, String className, Kind kind)
-      throws IOException {
+  public @Nullable JavaFileObject getJavaFileForInput(
+      Location location, String className, Kind kind) throws IOException {
     if (location.isOutputLocation()) {
-      return inMemoryFileObjects.getIfPresent(uriForJavaFileObject(location, className, kind));
-    } else {
-      return super.getJavaFileForInput(location, className, kind);
+      return inMemoryOutputs.getIfPresent(uriForJavaFileObject(location, className, kind));
+    }
+    Optional inMemoryInput = findInMemoryInput(className);
+    if (inMemoryInput.isPresent()) {
+      return inMemoryInput.get();
     }
+    return super.getJavaFileForInput(location, className, kind);
+  }
+
+  private Optional findInMemoryInput(String className) {
+    int lastDot = className.lastIndexOf('.');
+    return findInMemoryInput(
+        lastDot == -1 ? "" : className.substring(0, lastDot - 1),
+        className.substring(lastDot + 1) + ".java");
+  }
+
+  private Optional findInMemoryInput(String packageName, String relativeName) {
+    // Assume each input file's URI ends with the package/relative name. It might have other parts
+    // to the left.
+    String suffix =
+        packageName.isEmpty() ? relativeName : packageName.replace('.', '/') + "/" + relativeName;
+    return inMemoryInputs.entrySet().stream()
+        .filter(entry -> requireNonNull(entry.getKey().getPath()).endsWith(suffix))
+        .map(Map.Entry::getValue)
+        .collect(toOptional()); // Might have problems if more than one input file matches.
   }
 
   @Override
   public FileObject getFileForOutput(Location location, String packageName,
       String relativeName, FileObject sibling) throws IOException {
     URI uri = uriForFileObject(location, packageName, relativeName);
-    return inMemoryFileObjects.getUnchecked(uri);
+    return inMemoryOutputs.getUnchecked(uri);
   }
 
   @Override
   public JavaFileObject getJavaFileForOutput(Location location, String className, final Kind kind,
       FileObject sibling) throws IOException {
     URI uri = uriForJavaFileObject(location, className, kind);
-    return inMemoryFileObjects.getUnchecked(uri);
+    return inMemoryOutputs.getUnchecked(uri);
   }
 
   ImmutableList getGeneratedSources() {
     ImmutableList.Builder result = ImmutableList.builder();
-    for (Entry entry : inMemoryFileObjects.asMap().entrySet()) {
-      if (entry.getKey().getPath().startsWith("/" + StandardLocation.SOURCE_OUTPUT.name())
+    for (Map.Entry entry : inMemoryOutputs.asMap().entrySet()) {
+      if (requireNonNull(entry.getKey().getPath())
+              .startsWith("/" + StandardLocation.SOURCE_OUTPUT.name())
           && (entry.getValue().getKind() == Kind.SOURCE)) {
         result.add(entry.getValue());
       }
@@ -135,13 +162,20 @@ ImmutableList getGeneratedSources() {
   }
 
   ImmutableList getOutputFiles() {
-    return ImmutableList.copyOf(inMemoryFileObjects.asMap().values());
+    return ImmutableList.copyOf(inMemoryOutputs.asMap().values());
+  }
+
+  /** Adds files that should be available in the source path. */
+  void addSourceFiles(Iterable files) {
+    for (JavaFileObject file : files) {
+      inMemoryInputs.put(file.toUri(), file);
+    }
   }
 
   private static final class InMemoryJavaFileObject extends SimpleJavaFileObject
       implements JavaFileObject {
     private long lastModified = 0L;
-    private Optional data = Optional.absent();
+    private Optional data = Optional.empty();
 
     InMemoryJavaFileObject(URI uri) {
       super(uri, JavaFileObjects.deduceKind(uri));
@@ -207,14 +241,14 @@ public long getLastModified() {
 
     @Override
     public boolean delete() {
-      this.data = Optional.absent();
+      this.data = Optional.empty();
       this.lastModified = 0L;
       return true;
     }
 
     @Override
     public String toString() {
-      return Objects.toStringHelper(this)
+      return MoreObjects.toStringHelper(this)
           .add("uri", toUri())
           .add("kind", kind)
           .toString();
diff --git a/src/main/java/com/google/testing/compile/JavaFileObjectSubject.java b/src/main/java/com/google/testing/compile/JavaFileObjectSubject.java
new file mode 100644
index 00000000..80df4894
--- /dev/null
+++ b/src/main/java/com/google/testing/compile/JavaFileObjectSubject.java
@@ -0,0 +1,206 @@
+/*
+ * Copyright (C) 2016 Google, Inc.
+ *
+ * Licensed 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.
+ */
+package com.google.testing.compile;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static com.google.common.truth.Fact.fact;
+import static com.google.common.truth.Truth.assertAbout;
+import static com.google.testing.compile.JavaFileObjects.asByteSource;
+import static com.google.testing.compile.TreeDiffer.diffCompilationUnits;
+import static com.google.testing.compile.TreeDiffer.matchCompilationUnits;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.io.ByteSource;
+import com.google.common.truth.FailureMetadata;
+import com.google.common.truth.StringSubject;
+import com.google.common.truth.Subject;
+import com.google.testing.compile.Parser.ParseResult;
+import com.sun.source.tree.CompilationUnitTree;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.util.function.BiFunction;
+import javax.tools.JavaFileObject;
+import org.jspecify.annotations.Nullable;
+
+/** Assertions about {@link JavaFileObject}s. */
+public final class JavaFileObjectSubject extends Subject {
+
+  private static final Subject.Factory FACTORY =
+      new JavaFileObjectSubjectFactory();
+
+  /** Returns a {@link Subject.Factory} for {@link JavaFileObjectSubject}s. */
+  public static Subject.Factory javaFileObjects() {
+    return FACTORY;
+  }
+
+  /** Starts making assertions about a {@link JavaFileObject}. */
+  public static JavaFileObjectSubject assertThat(@Nullable JavaFileObject actual) {
+    return assertAbout(FACTORY).that(actual);
+  }
+
+  private final @Nullable JavaFileObject actual;
+
+  JavaFileObjectSubject(FailureMetadata failureMetadata, @Nullable JavaFileObject actual) {
+    super(failureMetadata, actual);
+    this.actual = actual;
+  }
+
+  @Override
+  protected String actualCustomStringRepresentation() {
+    return requireNonNull(actualNotNull().toUri().getPath());
+  }
+
+  /**
+   * If {@code other} is a {@link JavaFileObject}, tests that their contents are equal. Otherwise
+   * uses {@link Object#equals(Object)}.
+   */
+  @Override
+  public void isEqualTo(@Nullable Object other) {
+    if (!(other instanceof JavaFileObject)) {
+      super.isEqualTo(other);
+      return;
+    }
+
+    JavaFileObject otherFile = (JavaFileObject) other;
+    try {
+      if (!asByteSource(actualNotNull()).contentEquals(asByteSource(otherFile))) {
+        failWithActual("expected to be equal to", other);
+      }
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  /** Asserts that the actual file's contents are equal to {@code expected}. */
+  public void hasContents(ByteSource expected) {
+    try {
+      if (!asByteSource(actualNotNull()).contentEquals(expected)) {
+        failWithActual("expected to have contents", expected);
+      }
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  /**
+   * Returns a {@link StringSubject} that makes assertions about the contents of the actual file as
+   * a string.
+   */
+  public StringSubject contentsAsString(Charset charset) {
+    try {
+      return check("contents()")
+          .that(JavaFileObjects.asByteSource(actualNotNull()).asCharSource(charset).read());
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  /**
+   * Returns a {@link StringSubject} that makes assertions about the contents of the actual file as
+   * a UTF-8 string.
+   */
+  public StringSubject contentsAsUtf8String() {
+    return contentsAsString(UTF_8);
+  }
+
+  /**
+   * Asserts that the actual file is a source file that has an equivalent AST to that of {@code
+   * expectedSource}.
+   */
+  public void hasSourceEquivalentTo(JavaFileObject expectedSource) {
+    performTreeDifference(
+        expectedSource,
+        "expected to be equivalent to",
+        "expected",
+        (expectedResult, actualResult) ->
+            diffCompilationUnits(
+                getOnlyElement(expectedResult.compilationUnits()),
+                getOnlyElement(actualResult.compilationUnits())));
+  }
+
+  /**
+   * Asserts that the every node in the AST of {@code expectedPattern}
+   * exists in the actual file's AST, in the same order.
+   *
+   * 
Methods, constructors, fields, and types that are in the pattern must have the exact same
+   * modifiers and annotations as the actual AST. Ordering of AST nodes is also important (i.e. a
+   * type with identical members in a different order will fail the assertion). Types must match the
+   * entire type declaration: type parameters, {@code extends}/{@code implements} clauses, etc.
+   * Methods must also match the throws clause as well.
+   *
+   * 
The body of a method or constructor, or field initializer in the actual AST must match the
+   * pattern in entirety if the member is present in the pattern.
+   *
+   * 
Said in another way (from a graph-theoretic perspective): the pattern AST must be a subgraph
+   * of the actual AST. If a method, constructor, or field is in the pattern, that entire subtree,
+   * including modifiers and annotations, must be equal to the corresponding subtree in the actual
+   * AST (no proper subgraphs).
+   */
+  public void containsElementsIn(JavaFileObject expectedPattern) {
+    performTreeDifference(
+        expectedPattern,
+        "expected to contain elements in",
+        "expected pattern",
+        (expectedResult, actualResult) ->
+            matchCompilationUnits(
+                getOnlyElement(expectedResult.compilationUnits()),
+                actualResult.trees(),
+                getOnlyElement(actualResult.compilationUnits()),
+                expectedResult.trees()));
+  }
+
+  private void performTreeDifference(
+      JavaFileObject expected,
+      String failureVerb,
+      String expectedTitle,
+      BiFunction differencingFunction) {
+    ParseResult actualResult = Parser.parse(ImmutableList.of(actualNotNull()), "*actual* source");
+    CompilationUnitTree actualTree = getOnlyElement(actualResult.compilationUnits());
+
+    ParseResult expectedResult = Parser.parse(ImmutableList.of(expected), "*expected* source");
+    CompilationUnitTree expectedTree = getOnlyElement(expectedResult.compilationUnits());
+
+    TreeDifference treeDifference = differencingFunction.apply(expectedResult, actualResult);
+
+    if (!treeDifference.isEmpty()) {
+      String diffReport =
+          treeDifference.getDiffReport(
+              new TreeContext(expectedTree, expectedResult.trees()),
+              new TreeContext(actualTree, actualResult.trees()));
+      try {
+        failWithoutActual(
+            fact("for file", actualNotNull().toUri().getPath()),
+            fact(failureVerb, expected.toUri().getPath()),
+            fact("diff", diffReport),
+            fact(expectedTitle, expected.getCharContent(false)),
+            fact("but was", actualNotNull().getCharContent(false)));
+      } catch (IOException e) {
+        throw new IllegalStateException(
+            "Couldn't read from JavaFileObject when it was already in memory.", e);
+      }
+    }
+  }
+
+  private JavaFileObject actualNotNull() {
+    isNotNull();
+    return checkNotNull(actual);
+  }
+}
diff --git a/src/main/java/com/google/testing/compile/JavaFileObjectSubjectFactory.java b/src/main/java/com/google/testing/compile/JavaFileObjectSubjectFactory.java
new file mode 100644
index 00000000..174c29af
--- /dev/null
+++ b/src/main/java/com/google/testing/compile/JavaFileObjectSubjectFactory.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2016 Google, Inc.
+ *
+ * Licensed 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.
+ */
+package com.google.testing.compile;
+
+import com.google.common.truth.FailureMetadata;
+import com.google.common.truth.Subject;
+import javax.tools.JavaFileObject;
+import org.jspecify.annotations.Nullable;
+
+/** A factory for {@link JavaFileObjectSubject}s. */
+final class JavaFileObjectSubjectFactory
+    implements Subject.Factory {
+
+  @Override
+  public JavaFileObjectSubject createSubject(
+      FailureMetadata failureMetadata, @Nullable JavaFileObject that) {
+    return new JavaFileObjectSubject(failureMetadata, that);
+  }
+}
diff --git a/src/main/java/com/google/testing/compile/JavaFileObjects.java b/src/main/java/com/google/testing/compile/JavaFileObjects.java
index 0952bb62..174bd1e5 100644
--- a/src/main/java/com/google/testing/compile/JavaFileObjects.java
+++ b/src/main/java/com/google/testing/compile/JavaFileObjects.java
@@ -17,6 +17,7 @@
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
+import static java.util.Objects.requireNonNull;
 import static javax.tools.JavaFileObject.Kind.SOURCE;
 
 import com.google.common.base.CharMatcher;
@@ -25,7 +26,6 @@
 import com.google.common.collect.ImmutableList;
 import com.google.common.io.ByteSource;
 import com.google.common.io.Resources;
-
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
@@ -37,7 +37,6 @@
 import java.net.URL;
 import java.nio.charset.Charset;
 import java.util.Arrays;
-
 import javax.tools.ForwardingJavaFileObject;
 import javax.tools.JavaFileObject;
 import javax.tools.JavaFileObject.Kind;
@@ -60,7 +59,13 @@ private JavaFileObjects() { }
    * source and compilation errors may result if they do not match.
    */
   public static JavaFileObject forSourceString(String fullyQualifiedName, String source) {
-    return new StringSourceJavaFileObject(checkNotNull(fullyQualifiedName), checkNotNull(source));
+    checkNotNull(fullyQualifiedName);
+    if (fullyQualifiedName.startsWith("package ")) {
+      throw new IllegalArgumentException(
+          String.format("fullyQualifiedName starts with \"package\" (%s). Did you forget to "
+              + "specify the name and specify just the source text?",  fullyQualifiedName));
+    }
+    return new StringSourceJavaFileObject(fullyQualifiedName, checkNotNull(source));
   }
 
   private static final Joiner LINE_JOINER = Joiner.on('\n');
@@ -158,7 +163,7 @@ public static JavaFileObject forResource(String resourceName) {
   }
 
   static Kind deduceKind(URI uri) {
-    String path = uri.getPath();
+    String path = requireNonNull(uri.getPath());
     for (Kind kind : Kind.values()) {
       if (path.endsWith(kind.extension)) {
         return kind;
@@ -167,15 +172,20 @@ static Kind deduceKind(URI uri) {
     return Kind.OTHER;
   }
 
+  static ByteSource asByteSource(final JavaFileObject javaFileObject) {
+    return new ByteSource() {
+      @Override public InputStream openStream() throws IOException {
+        return javaFileObject.openInputStream();
+      }
+    };
+  }
+
   private static final class JarFileJavaFileObject
       extends ForwardingJavaFileObject {
-    final String name;
-
     JarFileJavaFileObject(URL jarUrl) {
       // this is a cheap way to give SimpleJavaFileObject a uri that satisfies the contract
       // then we just override the methods that we want to behave differently for jars
       super(new ResourceSourceJavaFileObject(jarUrl, getPathUri(jarUrl)));
-      this.name = jarUrl.toString();
     }
 
     static final Splitter JAR_URL_SPLITTER = Splitter.on('!');
@@ -189,11 +199,6 @@ static final URI getPathUri(URL jarUrl) {
           pathPart);
       return URI.create(pathPart);
     }
-
-    @Override
-    public String getName() {
-      return name;
-    }
   }
 
   private static final class ResourceSourceJavaFileObject extends SimpleJavaFileObject {
diff --git a/src/main/java/com/google/testing/compile/JavaSourceSubjectFactory.java b/src/main/java/com/google/testing/compile/JavaSourceSubjectFactory.java
index 80e8041c..ba477913 100644
--- a/src/main/java/com/google/testing/compile/JavaSourceSubjectFactory.java
+++ b/src/main/java/com/google/testing/compile/JavaSourceSubjectFactory.java
@@ -15,19 +15,19 @@
  */
 package com.google.testing.compile;
 
-import com.google.common.truth.FailureStrategy;
-import com.google.common.truth.SubjectFactory;
-
+import com.google.common.truth.FailureMetadata;
+import com.google.common.truth.Subject;
 import javax.tools.JavaFileObject;
+import org.jspecify.annotations.Nullable;
 
 /**
- * A Truth {@link SubjectFactory} similar to
+ * A Truth {@link Subject.Factory} similar to
  * {@link JavaSourcesSubjectFactory}, but for working with single source files.
  *
  * @author Gregory Kick
  */
 public final class JavaSourceSubjectFactory
-    extends SubjectFactory {
+    implements Subject.Factory {
   public static JavaSourceSubjectFactory javaSource() {
     return new JavaSourceSubjectFactory();
   }
@@ -35,8 +35,8 @@ public static JavaSourceSubjectFactory javaSource() {
   private JavaSourceSubjectFactory() {}
 
   @Override
-  public JavaSourcesSubject.SingleSourceAdapter getSubject(FailureStrategy failureStrategy,
-      JavaFileObject subject) {
-    return new JavaSourcesSubject.SingleSourceAdapter(failureStrategy, subject);
+  public JavaSourcesSubject.SingleSourceAdapter createSubject(
+      FailureMetadata failureMetadata, @Nullable JavaFileObject subject) {
+    return new JavaSourcesSubject.SingleSourceAdapter(failureMetadata, subject);
   }
 }
diff --git a/src/main/java/com/google/testing/compile/JavaSourcesSubject.java b/src/main/java/com/google/testing/compile/JavaSourcesSubject.java
index 44d25499..1687c2e8 100644
--- a/src/main/java/com/google/testing/compile/JavaSourcesSubject.java
+++ b/src/main/java/com/google/testing/compile/JavaSourcesSubject.java
@@ -15,14 +15,18 @@
  */
 package com.google.testing.compile;
 
-import static com.google.common.base.Preconditions.checkArgument;
-import static javax.tools.JavaFileObject.Kind.CLASS;
-
-import com.google.common.base.Function;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.truth.Fact.simpleFact;
+import static com.google.common.truth.Truth.assertAbout;
+import static com.google.testing.compile.CompilationSubject.compilations;
+import static com.google.testing.compile.Compiler.javac;
+import static com.google.testing.compile.JavaSourcesSubjectFactory.javaSources;
+import static com.google.testing.compile.TypeEnumerator.getTopLevelTypes;
+import static java.util.stream.Collectors.collectingAndThen;
+import static java.util.stream.Collectors.toList;
+
+import com.google.auto.value.AutoValue;
 import com.google.common.base.Joiner;
-import com.google.common.base.Optional;
-import com.google.common.base.Predicate;
-import com.google.common.collect.FluentIterable;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
@@ -30,35 +34,77 @@
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.google.common.io.ByteSource;
-import com.google.common.io.ByteStreams;
-import com.google.common.truth.FailureStrategy;
+import com.google.common.truth.FailureMetadata;
 import com.google.common.truth.Subject;
-import com.google.testing.compile.Compilation.Result;
-
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.testing.compile.CompilationSubject.DiagnosticAtColumn;
+import com.google.testing.compile.CompilationSubject.DiagnosticInFile;
+import com.google.testing.compile.CompilationSubject.DiagnosticOnLine;
+import com.google.testing.compile.Parser.ParseResult;
 import com.sun.source.tree.CompilationUnitTree;
-
+import java.io.File;
 import java.io.IOException;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Map;
-
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collector;
 import javax.annotation.processing.Processor;
 import javax.tools.Diagnostic;
 import javax.tools.Diagnostic.Kind;
-import javax.tools.FileObject;
+import javax.tools.JavaFileManager;
 import javax.tools.JavaFileObject;
+import org.jspecify.annotations.Nullable;
 
 /**
  * A Truth {@link Subject} that evaluates the result
- * of a {@code javac} compilation.  See {@link com.google.testing.compile} for usage examples
+ * of a {@code javac} compilation. See {@link com.google.testing.compile} for usage examples
  *
  * @author Gregory Kick
  */
 @SuppressWarnings("restriction") // Sun APIs usage intended
-public final class JavaSourcesSubject
-    extends Subject>
+public final class JavaSourcesSubject extends Subject
     implements CompileTester, ProcessedCompileTesterFactory {
-  JavaSourcesSubject(FailureStrategy failureStrategy, Iterable subject) {
-    super(failureStrategy, subject);
+  private final @Nullable Iterable actual;
+  private final List options = new ArrayList<>(Arrays.asList("-Xlint"));
+  @Nullable private ClassLoader classLoader;
+  @Nullable private ImmutableList classPath;
+
+  JavaSourcesSubject(
+      FailureMetadata failureMetadata, @Nullable Iterable actual) {
+    super(failureMetadata, actual);
+    this.actual = actual;
+  }
+
+  @Override
+  public JavaSourcesSubject withCompilerOptions(Iterable options) {
+    Iterables.addAll(this.options, options);
+    return this;
+  }
+
+  @Override
+  public JavaSourcesSubject withCompilerOptions(String... options) {
+    this.options.addAll(Arrays.asList(options));
+    return this;
+  }
+
+  /**
+   * @deprecated prefer {@link #withClasspath(Iterable)}. This method only supports {@link
+   *     java.net.URLClassLoader} and the default system classloader, and {@link File}s are usually
+   *     a more natural way to expression compilation classpaths than class loaders.
+   */
+  @Deprecated
+  @Override
+  public JavaSourcesSubject withClasspathFrom(ClassLoader classLoader) {
+    this.classLoader = classLoader;
+    return this;
+  }
+
+  @Override
+  public JavaSourcesSubject withClasspath(Iterable classPath) {
+    this.classPath = ImmutableList.copyOf(classPath);
+    return this;
   }
 
   @Override
@@ -71,11 +117,24 @@ public CompileTester processedWith(Iterable processors) {
     return new CompilationClause(processors);
   }
 
+  @Override
+  public void parsesAs(JavaFileObject first, JavaFileObject... rest) {
+    new CompilationClause().parsesAs(first, rest);
+  }
+
+  @CanIgnoreReturnValue
   @Override
   public SuccessfulCompilationClause compilesWithoutError() {
     return new CompilationClause().compilesWithoutError();
   }
 
+  @CanIgnoreReturnValue
+  @Override
+  public CleanCompilationClause compilesWithoutWarnings() {
+    return new CompilationClause().compilesWithoutWarnings();
+  }
+
+  @CanIgnoreReturnValue
   @Override
   public UnsuccessfulCompilationClause failsToCompile() {
     return new CompilationClause().failsToCompile();
@@ -86,81 +145,187 @@ private final class CompilationClause implements CompileTester {
     private final ImmutableSet processors;
 
     private CompilationClause() {
-      this(ImmutableSet.of());
+      this(ImmutableSet.of());
     }
 
     private CompilationClause(Iterable processors) {
       this.processors = ImmutableSet.copyOf(processors);
     }
 
-    /** Returns a {@code String} report describing the contents of a given generated file. */
-    private String reportFileGenerated(JavaFileObject generatedFile) {
-      try {
-        StringBuilder entry =
-            new StringBuilder().append(String.format("\n%s:\n", generatedFile.toUri().getPath()));
-        if (generatedFile.getKind().equals(CLASS)) {
-          entry.append(String.format("[generated class file (%s bytes)]",
-                  ByteSource.wrap(ByteStreams.toByteArray(generatedFile.openInputStream()))
-                  .size()));
-        } else {
-          entry.append(generatedFile.getCharContent(true));
+    @Override
+    public void parsesAs(JavaFileObject first, JavaFileObject... rest) {
+      if (Iterables.isEmpty(actualNotNull())) {
+        failWithoutActual(
+            simpleFact(
+                "Compilation generated no additional source files, though some were expected."));
+        return;
+      }
+      ParseResult actualResult = Parser.parse(actualNotNull(), "*actual* source");
+      ImmutableList> errors =
+          actualResult.diagnosticsByKind().get(Kind.ERROR);
+      if (!errors.isEmpty()) {
+        StringBuilder message = new StringBuilder("Parsing produced the following errors:\n");
+        for (Diagnostic error : errors) {
+          message.append('\n');
+          message.append(error);
         }
-        return entry.append("\n").toString();
-      } catch (IOException e) {
-        throw new IllegalStateException("Couldn't read from JavaFileObject when it was "
-            + "already in memory.", e);
+        failWithoutActual(simpleFact(message.toString()));
+        return;
       }
+      ParseResult expectedResult = Parser.parse(Lists.asList(first, rest), "*expected* source");
+      ImmutableList actualTrees =
+          actualResult.compilationUnits().stream()
+              .map(TypedCompilationUnit::create)
+              .collect(toImmutableList());
+      ImmutableList expectedTrees =
+          expectedResult.compilationUnits().stream()
+              .map(TypedCompilationUnit::create)
+              .collect(toImmutableList());
+
+      ImmutableMap> matchedTrees =
+          Maps.toMap(
+              expectedTrees,
+              expectedTree ->
+                  actualTrees.stream()
+                      .filter(actualTree -> expectedTree.types().equals(actualTree.types()))
+                      .findFirst());
+
+      matchedTrees.forEach(
+          (expectedTree, maybeActualTree) -> {
+            if (!maybeActualTree.isPresent()) {
+              failNoCandidates(expectedTree.types(), expectedTree.tree(), actualTrees);
+              return;
+            }
+            TypedCompilationUnit actualTree = maybeActualTree.get();
+            TreeDifference treeDifference =
+                TreeDiffer.diffCompilationUnits(expectedTree.tree(), actualTree.tree());
+            if (!treeDifference.isEmpty()) {
+              String diffReport =
+                  treeDifference.getDiffReport(
+                      new TreeContext(expectedTree.tree(), expectedResult.trees()),
+                      new TreeContext(actualTree.tree(), actualResult.trees()));
+              failWithCandidate(
+                  expectedTree.tree().getSourceFile(),
+                  actualTree.tree().getSourceFile(),
+                  diffReport);
+            }
+          });
     }
 
-    /**
-     * Returns a {@code String} report describing what files were generated in the given
-     * {@link Compilation.Result}
-     */
-    private String reportFilesGenerated(Compilation.Result result) {
-      FluentIterable generatedFiles =
-          FluentIterable.from(result.generatedSources());
-      StringBuilder message = new StringBuilder("\n\n");
-      if (generatedFiles.isEmpty()) {
-        return message.append("(No files were generated.)\n").toString();
-      } else {
-        message.append("Generated Files\n")
-            .append("===============\n");
-        for (JavaFileObject generatedFile : generatedFiles) {
-          message.append(reportFileGenerated(generatedFile));
-        }
-        return message.toString();
+    /** Called when the {@code generatesSources()} verb fails with no diff candidates. */
+    private void failNoCandidates(
+        ImmutableSet expectedTypes,
+        CompilationUnitTree expectedTree,
+        ImmutableList actualTrees) {
+      String generatedTypesReport =
+          Joiner.on('\n')
+              .join(
+                  actualTrees.stream()
+                      .map(
+                          generated ->
+                              String.format(
+                                  "- %s in <%s>",
+                                  generated.types(),
+                                  generated.tree().getSourceFile().toUri().getPath()))
+                      .collect(toList()));
+      failWithoutActual(
+          simpleFact(
+              Joiner.on('\n')
+                  .join(
+                      "",
+                      "An expected source declared one or more top-level types that were not "
+                          + "present.",
+                      "",
+                      String.format("Expected top-level types: <%s>", expectedTypes),
+                      String.format(
+                          "Declared by expected file: <%s>",
+                          expectedTree.getSourceFile().toUri().getPath()),
+                      "",
+                      "The top-level types that were present are as follows: ",
+                      "",
+                      generatedTypesReport,
+                      "")));
+    }
+
+    /** Called when the {@code generatesSources()} verb fails with a diff candidate. */
+    private void failWithCandidate(
+        JavaFileObject expectedSource, JavaFileObject actualSource, String diffReport) {
+      try {
+        failWithoutActual(
+            simpleFact(
+                Joiner.on('\n')
+                    .join(
+                        "",
+                        "Source declared the same top-level types of an expected source, but",
+                        "didn't match exactly.",
+                        "",
+                        String.format("Expected file: <%s>", expectedSource.toUri().getPath()),
+                        String.format("Actual file: <%s>", actualSource.toUri().getPath()),
+                        "",
+                        "Diffs:",
+                        "======",
+                        "",
+                        diffReport,
+                        "",
+                        "Expected Source: ",
+                        "================",
+                        "",
+                        expectedSource.getCharContent(false).toString(),
+                        "",
+                        "Actual Source:",
+                        "=================",
+                        "",
+                        actualSource.getCharContent(false).toString())));
+      } catch (IOException e) {
+        throw new IllegalStateException(
+            "Couldn't read from JavaFileObject when it was already " + "in memory.", e);
       }
     }
 
+    @CanIgnoreReturnValue
     @Override
     public SuccessfulCompilationClause compilesWithoutError() {
-      Compilation.Result result = Compilation.compile(processors, getSubject());
-      if (!result.successful()) {
-        ImmutableList> errors =
-            result.diagnosticsByKind().get(Kind.ERROR);
-        StringBuilder message = new StringBuilder("Compilation produced the following errors:\n");
-        for (Diagnostic error : errors) {
-          message.append('\n');
-          message.append(error);
-        }
-        message.append('\n');
-        message.append(reportFilesGenerated(result));
-        failureStrategy.fail(message.toString());
-      }
-      return new SuccessfulCompilationBuilder(result);
+      Compilation compilation = compilation();
+      check("compilation()").about(compilations()).that(compilation).succeeded();
+      return new SuccessfulCompilationBuilder(compilation);
     }
 
+    @CanIgnoreReturnValue
+    @Override
+    public CleanCompilationClause compilesWithoutWarnings() {
+      Compilation compilation = compilation();
+      check("compilation()").about(compilations()).that(compilation).succeededWithoutWarnings();
+      return new CleanCompilationBuilder(compilation);
+    }
+
+    @CanIgnoreReturnValue
     @Override
     public UnsuccessfulCompilationClause failsToCompile() {
-      Result result = Compilation.compile(processors, getSubject());
-      if (result.successful()) {
-        String message = Joiner.on('\n').join(
-            "Compilation was expected to fail, but contained no errors.",
-            "",
-            reportFilesGenerated(result));
-        failureStrategy.fail(message);
+      Compilation compilation = compilation();
+      check("compilation()").about(compilations()).that(compilation).failed();
+      return new UnsuccessfulCompilationBuilder(compilation);
+    }
+
+    private Compilation compilation() {
+      Compiler compiler = javac().withProcessors(processors).withOptions(options);
+      if (classLoader != null) {
+        compiler = compiler.withClasspathFrom(classLoader);
+      }
+      if (classPath != null) {
+        compiler = compiler.withClasspath(classPath);
       }
-      return new UnsuccessfulCompilationBuilder(result);
+      return compiler.compile(actualNotNull());
+    }
+  }
+
+  @AutoValue
+  abstract static class TypedCompilationUnit {
+    abstract CompilationUnitTree tree();
+
+    abstract ImmutableSet types();
+
+    static TypedCompilationUnit create(CompilationUnitTree tree) {
+      return new AutoValue_JavaSourcesSubject_TypedCompilationUnit(tree, getTopLevelTypes(tree));
     }
   }
 
@@ -172,282 +337,160 @@ private CompilationClause newCompilationClause(Iterable pro
     return new CompilationClause(processors);
   }
 
-  private final class UnsuccessfulCompilationBuilder implements UnsuccessfulCompilationClause {
-    private final Compilation.Result result;
+  /**
+   * Base implementation of {@link CompilationWithWarningsClause}.
+   *
+   * @param  the type parameter for {@link CompilationWithWarningsClause}. {@code this} must be
+   *     an instance of {@code T}; otherwise some calls will throw {@link ClassCastException}.
+   */
+  abstract class CompilationWithWarningsBuilder implements CompilationWithWarningsClause {
+    protected final Compilation compilation;
 
-    UnsuccessfulCompilationBuilder(Compilation.Result result) {
-      checkArgument(!result.successful());
-      this.result = result;
+    protected CompilationWithWarningsBuilder(Compilation compilation) {
+      this.compilation = compilation;
     }
 
+    @CanIgnoreReturnValue
     @Override
-    public FileClause withErrorContaining(final String messageFragment) {
-      FluentIterable> diagnostics =
-          FluentIterable.from(result.diagnosticsByKind().get(Kind.ERROR));
-      final FluentIterable> diagnosticsWithMessage =
-          diagnostics.filter(new Predicate>() {
-            @Override
-            public boolean apply(Diagnostic input) {
-              return input.getMessage(null).contains(messageFragment);
-            }
-          });
-      if (diagnosticsWithMessage.isEmpty()) {
-        failureStrategy.fail(String.format(
-            "Expected an error containing \"%s\", but only found %s", messageFragment,
-            diagnostics.transform(
-              new Function, String>() {
-                @Override public String apply(Diagnostic input) {
-                  return "\"" + input.getMessage(null) + "\"";
-                }
-              })));
-      }
-      return new FileClause() {
-        @Override
-        public UnsuccessfulCompilationClause and() {
-          return UnsuccessfulCompilationBuilder.this;
-        }
+    public T withNoteCount(int noteCount) {
+      check("compilation()").about(compilations()).that(compilation).hadNoteCount(noteCount);
+      return thisObject();
+    }
 
-        @Override
-        public LineClause in(final JavaFileObject file) {
-          final FluentIterable> diagnosticsInFile =
-              diagnosticsWithMessage.filter(new Predicate>() {
-                @Override
-                public boolean apply(Diagnostic input) {
-                  return ((input.getSource() != null)
-                      && file.toUri().getPath().equals(input.getSource().toUri().getPath()));
-                }
-              });
-          if (diagnosticsInFile.isEmpty()) {
-            failureStrategy.fail(String.format(
-                "Expected an error in %s, but only found errors in %s", file.getName(),
-                diagnosticsWithMessage.transform(
-                    new Function, String>() {
-                      @Override public String apply(Diagnostic input) {
-                        return (input.getSource() != null) ? input.getSource().getName()
-                            : "(no associated file)";
-                      }
-                    })
-                .toSet()));
-          }
-          return new LineClause() {
-            @Override public UnsuccessfulCompilationClause and() {
-              return UnsuccessfulCompilationBuilder.this;
-            }
+    @CanIgnoreReturnValue
+    @Override
+    public FileClause withNoteContaining(String messageFragment) {
+      return new FileBuilder(
+          check("compilation()")
+              .about(compilations())
+              .that(compilation)
+              .hadNoteContaining(messageFragment));
+    }
 
-            @Override public ColumnClause onLine(final long lineNumber) {
-              final FluentIterable> diagnosticsOnLine =
-                  diagnosticsWithMessage.filter(new Predicate>() {
-                    @Override
-                    public boolean apply(Diagnostic input) {
-                      return lineNumber == input.getLineNumber();
-                    }
-                  });
-              if (diagnosticsOnLine.isEmpty()) {
-                failureStrategy.fail(String.format(
-                    "Expected an error on line %d of %s, but only found errors on line(s) %s",
-                    lineNumber, file.getName(), diagnosticsInFile.transform(
-                        new Function, String>() {
-                          @Override public String apply(Diagnostic input) {
-                            long errLine = input.getLineNumber();
-                            return (errLine != Diagnostic.NOPOS) ? errLine + ""
-                                : "(no associated position)";
-                          }
-                        })
-                    .toSet()));
-              }
-              return new ColumnClause() {
-                @Override
-                public UnsuccessfulCompilationClause and() {
-                  return UnsuccessfulCompilationBuilder.this;
-                }
-
-                @Override
-                public ChainingClause atColumn(
-                    final long columnNumber) {
-                  FluentIterable> diagnosticsAtColumn =
-                      diagnosticsOnLine.filter(new Predicate>() {
-                        @Override
-                        public boolean apply(Diagnostic input) {
-                          return columnNumber == input.getColumnNumber();
-                        }
-                      });
-                  if (diagnosticsAtColumn.isEmpty()) {
-                    failureStrategy.fail(String.format(
-                        "Expected an error at %d:%d of %s, but only found errors at column(s) %s",
-                        lineNumber, columnNumber, file.getName(), diagnosticsOnLine.transform(
-                            new Function, String>() {
-                              @Override public String apply(Diagnostic input) {
-                                long errCol = input.getColumnNumber();
-                                return (errCol != Diagnostic.NOPOS) ? errCol + ""
-                                    : "(no associated position)";
-                              }
-                            })
-                        .toSet()));
-                  }
-                  return new ChainingClause() {
-                    @Override public UnsuccessfulCompilationClause and() {
-                      return UnsuccessfulCompilationBuilder.this;
-                    }
-                  };
-                }
-              };
-            }
-          };
-        }
-      };
+    @CanIgnoreReturnValue
+    @Override
+    public T withWarningCount(int warningCount) {
+      check("compilation()").about(compilations()).that(compilation).hadWarningCount(warningCount);
+      return thisObject();
     }
-  }
 
-  private final class SuccessfulCompilationBuilder implements SuccessfulCompilationClause,
-      GeneratedPredicateClause {
-    private final Compilation.Result result;
+    @CanIgnoreReturnValue
+    @Override
+    public FileClause withWarningContaining(String messageFragment) {
+      return new FileBuilder(
+          check("compilation()")
+              .about(compilations())
+              .that(compilation)
+              .hadWarningContaining(messageFragment));
+    }
 
-    SuccessfulCompilationBuilder(Compilation.Result result) {
-      checkArgument(result.successful());
-      this.result = result;
+    @CanIgnoreReturnValue
+    public T withErrorCount(int errorCount) {
+      check("compilation()").about(compilations()).that(compilation).hadErrorCount(errorCount);
+      return thisObject();
     }
 
-    @Override
-    public GeneratedPredicateClause and() {
-      return this;
+    @CanIgnoreReturnValue
+    public FileClause withErrorContaining(String messageFragment) {
+      return new FileBuilder(
+          check("compilation()")
+              .about(compilations())
+              .that(compilation)
+              .hadErrorContaining(messageFragment));
     }
 
-    @Override
-    public SuccessfulCompilationClause generatesSources(JavaFileObject first,
-        JavaFileObject... rest) {
-
-      final Compilation.ParseResult actualResult = Compilation.parse(result.generatedSources());
-      final Compilation.ParseResult expectedResult = Compilation.parse(Lists.asList(first, rest));
-      final FluentIterable actualTrees = FluentIterable.from(
-          actualResult.compilationUnits());
-      final FluentIterable expectedTrees = FluentIterable.from(
-          expectedResult.compilationUnits());
-
-      Function> getTypesFunction =
-          new Function>() {
-            @Override public ImmutableSet apply(CompilationUnitTree compilationUnit) {
-              return TypeEnumerator.getTopLevelTypes(compilationUnit);
-            }
-      };
+    /** Returns this object, cast to {@code T}. */
+    @SuppressWarnings("unchecked")
+    protected final T thisObject() {
+      return (T) this;
+    }
 
-      final ImmutableMap> expectedTreeTypes =
-          Maps.toMap(expectedTrees, getTypesFunction);
-      final ImmutableMap> actualTreeTypes =
-          Maps.toMap(actualTrees, getTypesFunction);
-      final ImmutableMap>
-          matchedTrees = Maps.toMap(expectedTrees,
-              new Function>() {
-                @Override public Optional apply(
-                    final CompilationUnitTree expectedTree) {
-                  return Iterables.tryFind(actualTrees,
-                      new Predicate() {
-                        @Override public boolean apply(CompilationUnitTree actualTree) {
-                          return expectedTreeTypes.get(expectedTree).equals(
-                              actualTreeTypes.get(actualTree));
-                        }
-                      });
-                }
-              });
-
-      for (Map.Entry>
-               matchedTreePair : matchedTrees.entrySet()) {
-        final CompilationUnitTree expectedTree = matchedTreePair.getKey();
-        if (!matchedTreePair.getValue().isPresent()) {
-          failNoCandidates(expectedTreeTypes.get(expectedTree), expectedTree,
-              actualTreeTypes, actualTrees);
-        } else {
-          CompilationUnitTree actualTree = matchedTreePair.getValue().get();
-          TreeDifference treeDifference = TreeDiffer.diffCompilationUnits(expectedTree, actualTree);
-          if (!treeDifference.isEmpty()) {
-            String diffReport = treeDifference.getDiffReport(
-                new TreeContext(expectedTree, expectedResult.trees()),
-                new TreeContext(actualTree, actualResult.trees()));
-            failWithCandidate(expectedTree.getSourceFile(), actualTree.getSourceFile(), diffReport);
+    private final class FileBuilder implements FileClause {
+      private final DiagnosticInFile diagnosticInFile;
+
+      private FileBuilder(DiagnosticInFile diagnosticInFile) {
+        this.diagnosticInFile = diagnosticInFile;
+      }
+
+      @Override
+      public T and() {
+        return thisObject();
+      }
+
+      @Override
+      public LineClause in(JavaFileObject file) {
+        final DiagnosticOnLine diagnosticOnLine = diagnosticInFile.inFile(file);
+
+        return new LineClause() {
+          @Override
+          public T and() {
+            return thisObject();
           }
-        }
+
+          @Override
+          public ColumnClause onLine(long lineNumber) {
+            final DiagnosticAtColumn diagnosticAtColumn = diagnosticOnLine.onLine(lineNumber);
+
+            return new ColumnClause() {
+              @Override
+              public T and() {
+                return thisObject();
+              }
+
+              @Override
+              public ChainingClause atColumn(long columnNumber) {
+                diagnosticAtColumn.atColumn(columnNumber);
+                return this;
+              }
+            };
+          }
+        };
       }
-      return this;
     }
+  }
 
-    /** Called when the {@code generatesSources()} verb fails with no diff candidates. */
-    private void failNoCandidates(ImmutableSet expectedTypes,
-        CompilationUnitTree expectedTree,
-        final ImmutableMap> actualTypes,
-        FluentIterable actualTrees) {
-      String generatedTypesReport = Joiner.on('\n').join(
-          actualTrees.transform(new Function() {
-                @Override public String apply(CompilationUnitTree generated) {
-                  return String.format("- %s in <%s>",
-                      actualTypes.get(generated),
-                      generated.getSourceFile().toUri().getPath());
-                }
-              })
-          .toList());
-      failureStrategy.fail(Joiner.on('\n').join(
-          "",
-          "An expected source declared one or more top-level types that were not generated.",
-          "",
-          String.format("Expected top-level types: <%s>", expectedTypes),
-          String.format("Declared by expected file: <%s>",
-              expectedTree.getSourceFile().toUri().getPath()),
-          "",
-          "The top-level types that were generated are as follows: ",
-          "",
-          generatedTypesReport,
-          ""));
-    }
+  /**
+   * Base implementation of {@link GeneratedPredicateClause GeneratedPredicateClause} and {@link
+   * ChainingClause ChainingClause>}.
+   *
+   * @param  the type parameter to {@link GeneratedPredicateClause}. {@code this} must be an
+   *     instance of {@code T}.
+   */
+  private abstract class GeneratedCompilationBuilder extends CompilationWithWarningsBuilder
+      implements GeneratedPredicateClause, ChainingClause> {
 
-    /** Called when the {@code generatesSources()} verb fails with a diff candidate. */
-    private void failWithCandidate(JavaFileObject expectedSource,
-        JavaFileObject actualSource, String diffReport) {
-      try {
-        failureStrategy.fail(Joiner.on('\n').join(
-            "",
-            "A generated source declared the same top-level types of an expected source, but",
-            "didn't match exactly.",
-            "",
-            String.format("Expected file: <%s>", expectedSource.toUri().getPath()),
-            String.format("Generated file: <%s>", actualSource.toUri().getPath()),
-            "",
-            "Diffs:",
-            "======",
-            "",
-            diffReport,
-            "",
-            "Expected Source: ",
-            "================",
-            "",
-            expectedSource.getCharContent(false).toString(),
-            "",
-            "Actual Source:",
-            "=================",
-            "",
-            actualSource.getCharContent(false).toString()));
-      } catch (IOException e) {
-        throw new IllegalStateException("Couldn't read from JavaFileObject when it was already "
-            + "in memory.", e);
-      }
+    protected GeneratedCompilationBuilder(Compilation compilation) {
+      super(compilation);
     }
 
+    @CanIgnoreReturnValue
+    @Override
+    public T generatesSources(JavaFileObject first, JavaFileObject... rest) {
+      check("generatedSourceFiles()")
+          .about(javaSources())
+          .that(compilation.generatedSourceFiles())
+          .parsesAs(first, rest);
+      return thisObject();
+    }
 
+    @CanIgnoreReturnValue
     @Override
-    public SuccessfulCompilationClause generatesFiles(JavaFileObject first,
-        JavaFileObject... rest) {
+    public T generatesFiles(JavaFileObject first, JavaFileObject... rest) {
       for (JavaFileObject expected : Lists.asList(first, rest)) {
-        if (!wasGenerated(result, expected)) {
-          failureStrategy.fail("Did not find a generated file corresponding to "
-              + expected.getName());
+        if (!wasGenerated(expected)) {
+          failWithoutActual(
+              simpleFact("Did not find a generated file corresponding to " + expected.getName()));
         }
       }
-      return this;
+      return thisObject();
     }
 
-    boolean wasGenerated(Compilation.Result result, JavaFileObject expected) {
-      for (JavaFileObject generated : result.generatedFilesByKind().get(expected.getKind())) {
+    boolean wasGenerated(JavaFileObject expected) {
+      ByteSource expectedByteSource = JavaFileObjects.asByteSource(expected);
+      for (JavaFileObject generated : compilation.generatedFiles()) {
         try {
-          if (Arrays.equals(
-              ByteStreams.toByteArray(expected.openInputStream()),
-              ByteStreams.toByteArray(generated.openInputStream()))) {
+          if (generated.getKind().equals(expected.getKind())
+              && expectedByteSource.contentEquals(JavaFileObjects.asByteSource(generated))) {
             return true;
           }
         } catch (IOException e) {
@@ -456,17 +499,141 @@ boolean wasGenerated(Compilation.Result result, JavaFileObject expected) {
       }
       return false;
     }
+
+    @CanIgnoreReturnValue
+    @Override
+    public SuccessfulFileClause generatesFileNamed(
+        JavaFileManager.Location location, String packageName, String relativeName) {
+      final JavaFileObjectSubject javaFileObjectSubject =
+          check("compilation()")
+              .about(compilations())
+              .that(compilation)
+              .generatedFile(location, packageName, relativeName);
+      return new SuccessfulFileClause() {
+        @Override
+        public GeneratedPredicateClause and() {
+          return GeneratedCompilationBuilder.this;
+        }
+
+        @Override
+        public SuccessfulFileClause withContents(ByteSource expectedByteSource) {
+          javaFileObjectSubject.hasContents(expectedByteSource);
+          return this;
+        }
+
+        @Override
+        public SuccessfulFileClause withStringContents(Charset charset, String expectedString) {
+          javaFileObjectSubject.contentsAsString(charset).isEqualTo(expectedString);
+          return this;
+        }
+      };
+    }
+
+    @Override
+    public GeneratedPredicateClause and() {
+      return this;
+    }
   }
 
-  public static final class SingleSourceAdapter
-      extends Subject
+  final class CompilationBuilder extends GeneratedCompilationBuilder {
+    CompilationBuilder(Compilation compilation) {
+      super(compilation);
+    }
+  }
+
+  private final class UnsuccessfulCompilationBuilder
+      extends CompilationWithWarningsBuilder
+      implements UnsuccessfulCompilationClause {
+
+    UnsuccessfulCompilationBuilder(Compilation compilation) {
+      super(compilation);
+    }
+  }
+
+  private final class SuccessfulCompilationBuilder
+      extends GeneratedCompilationBuilder
+      implements SuccessfulCompilationClause {
+
+    SuccessfulCompilationBuilder(Compilation compilation) {
+      super(compilation);
+    }
+  }
+
+  private final class CleanCompilationBuilder
+      extends GeneratedCompilationBuilder
+      implements CleanCompilationClause {
+
+    CleanCompilationBuilder(Compilation compilation) {
+      super(compilation);
+    }
+  }
+
+  public static JavaSourcesSubject assertThat(JavaFileObject javaFileObject) {
+    return assertAbout(javaSources()).that(ImmutableList.of(javaFileObject));
+  }
+
+  public static JavaSourcesSubject assertThat(
+      JavaFileObject javaFileObject, JavaFileObject... javaFileObjects) {
+    return assertAbout(javaSources())
+        .that(
+            ImmutableList.builder()
+                .add(javaFileObject)
+                .add(javaFileObjects)
+                .build());
+  }
+
+  private Iterable actualNotNull() {
+    isNotNull();
+    return checkNotNull(actual);
+  }
+
+  private static  Collector> toImmutableList() {
+    return collectingAndThen(toList(), ImmutableList::copyOf);
+  }
+
+  public static final class SingleSourceAdapter extends Subject
       implements CompileTester, ProcessedCompileTesterFactory {
     private final JavaSourcesSubject delegate;
 
-    SingleSourceAdapter(FailureStrategy failureStrategy, JavaFileObject subject) {
-      super(failureStrategy, subject);
+    SingleSourceAdapter(FailureMetadata failureMetadata, @Nullable JavaFileObject subject) {
+      super(failureMetadata, subject);
+      /*
+       * TODO(b/131918061): It would make more sense to eliminate SingleSourceAdapter entirely.
+       * Users can already use assertThat(JavaFileObject, JavaFileObject...) above for a single
+       * file. Anyone who needs a Subject.Factory could fall back to
+       * `about(javaSources()).that(ImmutableSet.of(source))`.
+       *
+       * We could take that on, or we could wait for JavaSourcesSubject to go away entirely in favor
+       * of CompilationSubject.
+       */
       this.delegate =
-          new JavaSourcesSubject(failureStrategy, ImmutableList.of(subject));
+          check("delegate()").about(javaSources()).that(ImmutableList.of(checkNotNull(subject)));
+    }
+
+    @Override
+    public JavaSourcesSubject withCompilerOptions(Iterable options) {
+      return delegate.withCompilerOptions(options);
+    }
+
+    @Override
+    public JavaSourcesSubject withCompilerOptions(String... options) {
+      return delegate.withCompilerOptions(options);
+    }
+
+    /**
+     * @deprecated prefer {@link #withClasspath(Iterable)}. This method only supports {@link
+     *     java.net.URLClassLoader} and the default system classloader, and {@link File}s are
+     *     usually a more natural way to expression compilation classpaths than class loaders.
+     */
+    @Deprecated
+    @Override
+    public JavaSourcesSubject withClasspathFrom(ClassLoader classLoader) {
+      return delegate.withClasspathFrom(classLoader);
+    }
+
+    @Override
+    public JavaSourcesSubject withClasspath(Iterable classPath) {
+      return delegate.withClasspath(classPath);
     }
 
     @Override
@@ -479,14 +646,27 @@ public CompileTester processedWith(Iterable processors) {
       return delegate.newCompilationClause(processors);
     }
 
+    @CanIgnoreReturnValue
     @Override
     public SuccessfulCompilationClause compilesWithoutError() {
       return delegate.compilesWithoutError();
     }
 
+    @CanIgnoreReturnValue
+    @Override
+    public CleanCompilationClause compilesWithoutWarnings() {
+      return delegate.compilesWithoutWarnings();
+    }
+
+    @CanIgnoreReturnValue
     @Override
     public UnsuccessfulCompilationClause failsToCompile() {
       return delegate.failsToCompile();
     }
+
+    @Override
+    public void parsesAs(JavaFileObject first, JavaFileObject... rest) {
+      delegate.parsesAs(first, rest);
+    }
   }
 }
diff --git a/src/main/java/com/google/testing/compile/JavaSourcesSubjectFactory.java b/src/main/java/com/google/testing/compile/JavaSourcesSubjectFactory.java
index 645f242a..517e21e1 100644
--- a/src/main/java/com/google/testing/compile/JavaSourcesSubjectFactory.java
+++ b/src/main/java/com/google/testing/compile/JavaSourcesSubjectFactory.java
@@ -15,19 +15,19 @@
  */
 package com.google.testing.compile;
 
-import com.google.common.truth.FailureStrategy;
-import com.google.common.truth.SubjectFactory;
-
+import com.google.common.truth.FailureMetadata;
+import com.google.common.truth.Subject;
 import javax.tools.JavaFileObject;
+import org.jspecify.annotations.Nullable;
 
 /**
- * A Truth {@link SubjectFactory} for creating
+ * A Truth {@link Subject.Factory} for creating
  * {@link JavaSourcesSubject} instances.
  *
  * @author Gregory Kick
  */
 public final class JavaSourcesSubjectFactory
-    extends SubjectFactory> {
+    implements Subject.Factory> {
   public static JavaSourcesSubjectFactory javaSources() {
     return new JavaSourcesSubjectFactory();
   }
@@ -35,8 +35,8 @@ public static JavaSourcesSubjectFactory javaSources() {
   private JavaSourcesSubjectFactory() {}
 
   @Override
-  public JavaSourcesSubject getSubject(FailureStrategy failureStrategy,
-      Iterable subject) {
-    return new JavaSourcesSubject(failureStrategy, subject);
+  public JavaSourcesSubject createSubject(
+      FailureMetadata failureMetadata, @Nullable Iterable subject) {
+    return new JavaSourcesSubject(failureMetadata, subject);
   }
 }
diff --git a/src/main/java/com/google/testing/compile/MoreTrees.java b/src/main/java/com/google/testing/compile/MoreTrees.java
index b9314657..9c4fd1d6 100644
--- a/src/main/java/com/google/testing/compile/MoreTrees.java
+++ b/src/main/java/com/google/testing/compile/MoreTrees.java
@@ -15,11 +15,10 @@
  */
 package com.google.testing.compile;
 
-import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
-
+import com.google.testing.compile.Parser.ParseResult;
 import com.sun.source.tree.BreakTree;
 import com.sun.source.tree.ClassTree;
 import com.sun.source.tree.CompilationUnitTree;
@@ -34,15 +33,15 @@
 import com.sun.source.tree.VariableTree;
 import com.sun.source.util.TreePath;
 import com.sun.source.util.TreePathScanner;
-
 import java.util.Arrays;
-
-import javax.annotation.Nullable;
+import java.util.Optional;
+import org.jspecify.annotations.Nullable;
 
 /**
  * A class containing methods which are useful for gaining access to {@code Tree} instances from
  * within unit tests.
  */
+@SuppressWarnings("restriction") // Sun APIs usage intended
 final class MoreTrees {
 
   /** Parses the source given into a {@link CompilationUnitTree}. */
@@ -52,25 +51,26 @@ static CompilationUnitTree parseLinesToTree(String... source) {
 
   /** Parses the source given into a {@link CompilationUnitTree}. */
   static CompilationUnitTree parseLinesToTree(Iterable source) {
-    Iterable parseResults = Compilation.parse(ImmutableList.of(
-        JavaFileObjects.forSourceLines("", source))).compilationUnits();
+    Iterable parseResults =
+        Parser.parse(ImmutableList.of(JavaFileObjects.forSourceLines("", source)), "source")
+            .compilationUnits();
     return Iterables.getOnlyElement(parseResults);
   }
 
-  /** Parses the source given and produces a {@link Compilation.ParseResult}. */
-  static Compilation.ParseResult parseLines(String... source) {
+  /** Parses the source given and produces a {@link ParseResult}. */
+  static ParseResult parseLines(String... source) {
     return parseLines(Arrays.asList(source));
   }
 
-  /** Parses the source given and produces a {@link Compilation.ParseResult}. */
-  static Compilation.ParseResult parseLines(Iterable source) {
-    return Compilation.parse(ImmutableList.of(JavaFileObjects.forSourceLines("", source)));
+  /** Parses the source given and produces a {@link ParseResult}. */
+  static ParseResult parseLines(Iterable source) {
+    return Parser.parse(ImmutableList.of(JavaFileObjects.forSourceLines("", source)), "source");
   }
 
   /**
    * Finds the first instance of the given {@link Tree.Kind} that is a subtree of the root provided.
    *
-   * @throw IllegalArgumentException if no such subtree exists.
+   * @throws IllegalArgumentException if no such subtree exists.
    */
   static Tree findSubtree(CompilationUnitTree root, Tree.Kind treeKind) {
     return findSubtree(root, treeKind, null);
@@ -82,10 +82,10 @@ static Tree findSubtree(CompilationUnitTree root, Tree.Kind treeKind) {
    *
    * 
See the doc on {@link #findSubtreePath} for details on the identifier param.
    *
-   * @throw IllegalArgumentException if no such subtree exists.
+   * @throws IllegalArgumentException if no such subtree exists.
    */
-  static Tree findSubtree(CompilationUnitTree root, Tree.Kind treeKind,
-      @Nullable String identifier) {
+  static Tree findSubtree(
+      CompilationUnitTree root, Tree.Kind treeKind, @Nullable String identifier) {
     return findSubtreePath(root, treeKind, identifier).getLeaf();
   }
 
@@ -93,7 +93,7 @@ static Tree findSubtree(CompilationUnitTree root, Tree.Kind treeKind,
    * Finds a path to the first instance of the given {@link Tree.Kind} that is a subtree of the root
    * provided.
    *
-   * @throw IllegalArgumentException if no such subtree exists.
+   * @throws IllegalArgumentException if no such subtree exists.
    */
   static TreePath findSubtreePath(CompilationUnitTree root, Tree.Kind treeKind) {
     return findSubtreePath(root, treeKind, null);
@@ -121,18 +121,15 @@ static TreePath findSubtreePath(CompilationUnitTree root, Tree.Kind treeKind) {
    */
   static TreePath findSubtreePath(CompilationUnitTree root, Tree.Kind treeKind,
       @Nullable String identifier) {
-    SearchScanner subtreeFinder = new SearchScanner(treeKind,
-        (identifier == null) ? Optional.absent() : Optional.of(identifier));
+    SearchScanner subtreeFinder = new SearchScanner(treeKind, Optional.ofNullable(identifier));
     Optional res = subtreeFinder.scan(root, null);
     Preconditions.checkArgument(res.isPresent(), "Couldn't find any subtree matching the given "
         + "criteria. Root: %s, Class: %s, Identifier: %s", root, treeKind, identifier);
     return res.get();
   }
 
-  /**
-   * A {@link TreePathScanner} to power the subtree searches in this class
-   */
-  static final class SearchScanner extends TreePathScanner, Void> {
+  /** A {@link TreePathScanner} to power the subtree searches in this class */
+  static final class SearchScanner extends TreePathScanner, @Nullable Void> {
     private final Optional identifier;
     private final Tree.Kind kindSought;
 
@@ -152,8 +149,7 @@ private boolean isMatch(Tree node, Optional

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.