src/jdk.compiler/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java

*** 29,38 ****
--- 29,39 ----
  import java.io.File;
  import java.io.IOException;
  import java.io.PrintWriter;
  import java.io.StringWriter;
  import java.lang.reflect.Method;
+ import java.lang.reflect.Constructor;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.nio.file.Path;
  import java.util.*;
  import java.util.regex.*;
*** 280,292 ****
      private void initProcessorIterator(Iterable<? extends Processor> processors) {
          Iterator<? extends Processor> processorIterator;
  
          if (options.isSet(XPRINT)) {
              try {
!                 @SuppressWarnings("deprecation")
!                 Processor processor = PrintingProcessor.class.newInstance();
!                 processorIterator = List.of(processor).iterator();
              } catch (Throwable t) {
                  AssertionError assertError =
                      new AssertionError("Problem instantiating PrintingProcessor.");
                  assertError.initCause(t);
                  throw assertError;
--- 281,291 ----
      private void initProcessorIterator(Iterable<? extends Processor> processors) {
          Iterator<? extends Processor> processorIterator;
  
          if (options.isSet(XPRINT)) {
              try {
!                 processorIterator = List.of(new PrintingProcessor()).iterator();
              } catch (Throwable t) {
                  AssertionError assertError =
                      new AssertionError("Problem instantiating PrintingProcessor.");
                  assertError.initCause(t);
                  throw assertError;
*** 538,580 ****
  
          public boolean hasNext() {
              if (nextProc != null)
                  return true;
              else {
!                 if (!names.hasNext())
                      return false;
!                 else {
!                     String processorName = names.next();
  
!                     Processor processor;
                      try {
                          try {
                              Class<?> processorClass = processorCL.loadClass(processorName);
                              ensureReadable(processorClass);
!                             @SuppressWarnings("deprecation")
!                             Object tmp = processorClass.newInstance();
!                             processor = (Processor) tmp;
                          } catch (ClassNotFoundException cnfe) {
                              log.error("proc.processor.not.found", processorName);
!                             return false;
                          } catch (ClassCastException cce) {
                              log.error("proc.processor.wrong.type", processorName);
!                             return false;
                          } catch (Exception e ) {
                              log.error("proc.processor.cant.instantiate", processorName);
!                             return false;
                          }
!                     } catch(ClientCodeException e) {
                          throw e;
!                     } catch(Throwable t) {
                          throw new AnnotationProcessingError(t);
                      }
-                     nextProc = processor;
-                     return true;
-                 }
- 
-             }
          }
  
          public Processor next() {
              if (hasNext()) {
                  Processor p = nextProc;
--- 537,584 ----
  
          public boolean hasNext() {
              if (nextProc != null)
                  return true;
              else {
!                 if (!names.hasNext()) {
                      return false;
!                 } else {
!                     Processor processor = getNextProcessor(names.next());
!                     if (processor == null) {
!                         return false;
!                     } else {
!                         nextProc = processor;
!                         return true;
!                     }
!                 }
!             }
!         }
  
!         private static final Class<?>[] EMPTY_PARAMETERS = new Class<?>[0];
! 
!         private Processor getNextProcessor(String processorName) {
              try {
                  try {
                      Class<?> processorClass = processorCL.loadClass(processorName);
                      ensureReadable(processorClass);
!                     Constructor<?> ctor  = processorClass.getConstructor(EMPTY_PARAMETERS);
!                     return (Processor) (ctor.newInstance((Object[])null));
                  } catch (ClassNotFoundException cnfe) {
                      log.error("proc.processor.not.found", processorName);
!                     return null;
                  } catch (ClassCastException cce) {
                      log.error("proc.processor.wrong.type", processorName);
!                     return null;
                  } catch (Exception e ) {
                      log.error("proc.processor.cant.instantiate", processorName);
!                     return null;
                  }
!             } catch (ClientCodeException e) {
                  throw e;
!             } catch (Throwable t) {
                  throw new AnnotationProcessingError(t);
              }
          }
  
          public Processor next() {
              if (hasNext()) {
                  Processor p = nextProc;