Suppress formatting exceptions in FormattingFiler

When developing an annotation processor which uses this code, throwing
an exception hides the problematic code from the developer. This change
emits the unformatted code so it can be debugged.

MOE_MIGRATED_REVID=146717858

Author: sir-buckyball

core/src/main/java/com/google/googlejavaformat/java/filer/FormattingFiler.java

@@ -18,7 +18,9 @@
 
 import com.google.googlejavaformat.java.Formatter;
 import java.io.IOException;
+import javax.annotation.Nullable;
 import javax.annotation.processing.Filer;
+import javax.annotation.processing.Messager;
 import javax.lang.model.element.Element;
 import javax.tools.FileObject;
 import javax.tools.JavaFileManager;
@@ -33,17 +35,30 @@ public final class FormattingFiler implements Filer {
   private final Filer delegate;
   // TODO(ronshapiro): consider allowing users to create their own Formatter instance
   private final Formatter formatter = new Formatter();
+  private final Messager messager;
 
   /** @param delegate filer to decorate */
   public FormattingFiler(Filer delegate) {
+    this(delegate, null);
+  }
+
+  /**
+   * Create a new {@link FormattingFiler}. An optional {@link Messager} may be specified to make
+   * logs more visible.
+   *
+   * @param delegate filer to decorate
+   * @param messager to log warnings to
+   */
+  public FormattingFiler(Filer delegate, @Nullable Messager messager) {
     this.delegate = checkNotNull(delegate);
+    this.messager = messager;
   }
 
   @Override
   public JavaFileObject createSourceFile(CharSequence name, Element... originatingElements)
       throws IOException {
     return new FormattingJavaFileObject(
-        delegate.createSourceFile(name, originatingElements), formatter);
+        delegate.createSourceFile(name, originatingElements), formatter, messager);
   }
 
   @Override

core/src/main/java/com/google/googlejavaformat/java/filer/FormattingJavaFileObject.java

@@ -22,6 +22,9 @@
 import com.google.googlejavaformat.java.FormatterException;
 import java.io.IOException;
 import java.io.Writer;
+import javax.annotation.Nullable;
+import javax.annotation.processing.Messager;
+import javax.tools.Diagnostic;
 import javax.tools.ForwardingJavaFileObject;
 import javax.tools.JavaFileObject;
 
@@ -31,11 +34,19 @@ final class FormattingJavaFileObject extends ForwardingJavaFileObject<JavaFileOb
   private static final int DEFAULT_FILE_SIZE = 80 * 500;
 
   private final Formatter formatter;
+  private final Messager messager;
 
-  /** @param delegate {@link JavaFileObject} to decorate */
-  FormattingJavaFileObject(JavaFileObject delegate, Formatter formatter) {
+  /**
+   * Create a new {@link FormattingJavaFileObject}.
+   *
+   * @param delegate {@link JavaFileObject} to decorate
+   * @param messager to log messages with.
+   */
+  FormattingJavaFileObject(
+      JavaFileObject delegate, Formatter formatter, @Nullable Messager messager) {
     super(checkNotNull(delegate));
     this.formatter = checkNotNull(formatter);
+    this.messager = messager;
   }
 
   @Override
@@ -62,7 +73,15 @@ public Writer openStream() throws IOException {
                 }
               });
         } catch (FormatterException e) {
-          throw new IOException("Error formatting " + getName(), e);
+          // An exception will happen when the code being formatted has an error. It's better to
+          // log the exception and emit unformatted code so the developer can view the code which
+          // caused a problem.
+          try (Writer writer = fileObject.openWriter()) {
+            writer.append(stringBuilder.toString());
+          }
+          if (messager != null) {
+            messager.printMessage(Diagnostic.Kind.NOTE, "Error formatting " + getName());
+          }
         }
       }
     };

core/src/test/java/com/google/googlejavaformat/java/filer/FormattingFilerTest.java

@@ -15,16 +15,19 @@
 package com.google.googlejavaformat.java.filer;
 
 import static com.google.common.truth.Truth.assertThat;
-import static org.junit.Assert.fail;
 
 import com.google.common.base.Joiner;
-import com.google.googlejavaformat.java.FormatterException;
 import com.google.testing.compile.CompilationRule;
 import java.io.IOException;
 import java.io.StringWriter;
 import java.io.Writer;
 import java.net.URI;
+import java.util.ArrayList;
+import java.util.List;
 import javax.annotation.processing.Filer;
+import javax.annotation.processing.Messager;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
 import javax.lang.model.element.Element;
 import javax.tools.FileObject;
 import javax.tools.JavaFileManager.Location;
@@ -43,18 +46,38 @@ public class FormattingFilerTest {
   @Rule public CompilationRule compilationRule = new CompilationRule();
 
   @Test
-  public void invalidSyntaxThrowsError() throws IOException {
+  public void invalidSyntaxDoesNotThrowError() throws IOException {
+    List<String> logMessages = new ArrayList<>();
+    Messager messager =
+        new Messager() {
+          @Override
+          public void printMessage(javax.tools.Diagnostic.Kind kind, CharSequence msg) {
+            logMessages.add(kind.toString() + ";" + msg);
+          }
+
+          @Override
+          public void printMessage(javax.tools.Diagnostic.Kind kind, CharSequence msg, Element e) {}
+
+          @Override
+          public void printMessage(
+              javax.tools.Diagnostic.Kind kind, CharSequence msg, Element e, AnnotationMirror a) {}
+
+          @Override
+          public void printMessage(
+              javax.tools.Diagnostic.Kind kind,
+              CharSequence msg,
+              Element e,
+              AnnotationMirror a,
+              AnnotationValue v) {}
+        };
+
     String file = Joiner.on('\n').join("package foo;", "public class Bar {");
-    FormattingFiler formattingFiler = new FormattingFiler(new FakeFiler());
+    FormattingFiler formattingFiler = new FormattingFiler(new FakeFiler(), messager);
     Writer writer = formattingFiler.createSourceFile("foo.Bar").openWriter();
     writer.write(file);
-    try {
-      writer.close();
-      fail("An exception should be thrown if formatting fails");
-    } catch (IOException expected) {
-      assertThat(expected.getMessage()).contains("foo.Bar");
-      assertThat(expected.getCause().getClass()).isAssignableTo(FormatterException.class);
-    }
+    writer.close();
+
+    assertThat(logMessages).containsExactly("NOTE;Error formatting foo.Bar");
   }
 
   @Test