From dc4bc4f0844b768e83406f44f2a9ee50686b1d9d Mon Sep 17 00:00:00 2001 From: Joe Darcy Date: Fri, 6 Oct 2023 21:45:58 +0000 Subject: [PATCH] 8306819: Consider disabling the compiler's default active annotation processing Reviewed-by: vromero --- .../sun/tools/javac/main/JavaCompiler.java | 17 +++----- .../tools/javac/6341866/T6341866.java | 18 +++----- .../tools/javac/diags/examples.not-yet.txt | 4 ++ .../ProcUseProcOrImplicit.java | 2 - .../options/TestNoteOnImplicitProcessing.java | 43 ++++++++++++------- 5 files changed, 46 insertions(+), 38 deletions(-) diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/main/JavaCompiler.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/main/JavaCompiler.java index 10f4d609c68..82a7465821d 100644 --- a/src/jdk.compiler/share/classes/com/sun/tools/javac/main/JavaCompiler.java +++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/main/JavaCompiler.java @@ -1144,21 +1144,18 @@ public class JavaCompiler { if (processors != null && processors.iterator().hasNext()) explicitAnnotationProcessingRequested = true; - // Process annotations if processing is not disabled and there - // is at least one Processor available. if (options.isSet(PROC, "none")) { processAnnotations = false; } else if (procEnvImpl == null) { procEnvImpl = JavacProcessingEnvironment.instance(context); procEnvImpl.setProcessors(processors); - processAnnotations = procEnvImpl.atLeastOneProcessor(); + + // Process annotations if processing is requested and there + // is at least one Processor available. + processAnnotations = procEnvImpl.atLeastOneProcessor() && + explicitAnnotationProcessingRequested(); if (processAnnotations) { - if (!explicitAnnotationProcessingRequested() && - !optionsCheckingInitiallyDisabled) { - log.note(Notes.ImplicitAnnotationProcessing); - } - options.put("parameters", "parameters"); reader.saveParameterNames = true; keepComments = true; @@ -1167,9 +1164,9 @@ public class JavaCompiler { taskListener.started(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING)); deferredDiagnosticHandler = new Log.DeferredDiagnosticHandler(log); procEnvImpl.getFiler().setInitialState(initialFiles, initialClassNames); - } else { // free resources - procEnvImpl.close(); } + } else { // free resources + procEnvImpl.close(); } } diff --git a/test/langtools/tools/javac/6341866/T6341866.java b/test/langtools/tools/javac/6341866/T6341866.java index dac0058e250..c04653ed58d 100644 --- a/test/langtools/tools/javac/6341866/T6341866.java +++ b/test/langtools/tools/javac/6341866/T6341866.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2006, 2015, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2006, 2023, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -56,8 +56,8 @@ public class T6341866 { enum ImplicitType { NONE(null), // don't use implicit compilation OPT_UNSET(null), // implicit compilation, but no -implicit option - OPT_NONE("-implicit:none"), // implicit compilation wiith -implicit:none - OPT_CLASS("-implicit:class"); // implicit compilation wiith -implicit:class + OPT_NONE("-implicit:none"), // implicit compilation with -implicit:none + OPT_CLASS("-implicit:class"); // implicit compilation with -implicit:class ImplicitType(String opt) { this.opt = opt; @@ -67,7 +67,6 @@ public class T6341866 { enum AnnoType { NONE, // no annotation processing - SERVICE, // implicit annotation processing, via ServiceLoader SPECIFY // explicit annotation processing }; @@ -99,14 +98,14 @@ public class T6341866 { processorServices.delete(); List opts = new ArrayList(); - opts.addAll(Arrays.asList("-d", ".", "-sourcepath", testSrc, "-classpath", testClasses, "-Xlint:-options")); + opts.addAll(Arrays.asList("-d", ".", + "-sourcepath", testSrc, + "-classpath", testClasses, + "-proc:full")); if (implicitType.opt != null) opts.add(implicitType.opt); switch (annoType) { - case SERVICE: - createProcessorServices(Anno.class.getName()); - break; case SPECIFY: opts.addAll(Arrays.asList("-processor", Anno.class.getName())); break; @@ -145,9 +144,6 @@ public class T6341866 { String expectKey = null; if (implicitType == ImplicitType.OPT_UNSET) { switch (annoType) { - case SERVICE: - expectKey = "compiler.warn.proc.use.proc.or.implicit"; - break; case SPECIFY: expectKey = "compiler.warn.proc.use.implicit"; break; diff --git a/test/langtools/tools/javac/diags/examples.not-yet.txt b/test/langtools/tools/javac/diags/examples.not-yet.txt index 7245c10aa01..06b7cea1afe 100644 --- a/test/langtools/tools/javac/diags/examples.not-yet.txt +++ b/test/langtools/tools/javac/diags/examples.not-yet.txt @@ -218,3 +218,7 @@ compiler.err.annotation.unrecognized.attribute.name # this one is transitional (waiting for FFM API to exit preview) compiler.warn.restricted.method + +# Pending removal +compiler.note.implicit.annotation.processing +compiler.warn.proc.use.proc.or.implicit diff --git a/test/langtools/tools/javac/diags/examples/ProcUseProcOrImplicit/ProcUseProcOrImplicit.java b/test/langtools/tools/javac/diags/examples/ProcUseProcOrImplicit/ProcUseProcOrImplicit.java index 3a697d40cf8..6d9d9a70ee9 100644 --- a/test/langtools/tools/javac/diags/examples/ProcUseProcOrImplicit/ProcUseProcOrImplicit.java +++ b/test/langtools/tools/javac/diags/examples/ProcUseProcOrImplicit/ProcUseProcOrImplicit.java @@ -21,8 +21,6 @@ * questions. */ -// key: compiler.warn.proc.use.proc.or.implicit -// key: compiler.note.implicit.annotation.processing // options: -Xprefer:source import p.SomeClass; diff --git a/test/langtools/tools/javac/processing/options/TestNoteOnImplicitProcessing.java b/test/langtools/tools/javac/processing/options/TestNoteOnImplicitProcessing.java index 81efbce05aa..9d23707c618 100644 --- a/test/langtools/tools/javac/processing/options/TestNoteOnImplicitProcessing.java +++ b/test/langtools/tools/javac/processing/options/TestNoteOnImplicitProcessing.java @@ -23,8 +23,8 @@ /* * @test - * @bug 8310061 8315534 - * @summary Verify a note is issued for implicit annotation processing + * @bug 8310061 8315534 8306819 + * @summary Verify behavior around implicit annotation processing * * @library /tools/lib /tools/javac/lib * @modules @@ -59,19 +59,27 @@ import toolbox.ToolBox; import toolbox.JarTask; /* - * Generates note and the processor runs: + * Does not generates a note and the processor does not run: * $ javac -cp ImplicitProcTestProc.jar HelloWorldTest.java * - * Does _not_ generate a note and the processor runs: + * Does _not_ generate a note and the processor does run: * $ javac -processorpath ImplicitProcTestProc.jar HelloWorldTest.java * $ javac -cp ImplicitProcTestProc.jar -processor ImplicitProcTestProc.jar HelloWorldTest.java * $ javac -cp ImplicitProcTestProc.jar -proc:full HelloWorldTest.java * $ javac -cp ImplicitProcTestProc.jar -proc:only HelloWorldTest.java + * + * Does _not_ generate a note and the processor does _not_run: * $ javac -cp ImplicitProcTestProc.jar -Xlint:-options HelloWorldTest.java * $ javac -cp ImplicitProcTestProc.jar -Xlint:none HelloWorldTest.java * * Does _not_ generate a note and the processor _doesn't_ run. * $ javac -cp ImplicitProcTestProc.jar -proc:none HelloWorldTest.java + * + * (Previously, annotation processing was implicitly enabled and the + * the class path was searched for processors. This test was + * originally written to probe around a note warning of a potential + * future policy change to disable such implicit processing, a policy + * change now implemented and this test has been updated accordingly.) */ public class TestNoteOnImplicitProcessing extends TestRunner { @@ -165,8 +173,8 @@ public class TestNoteOnImplicitProcessing extends TestRunner { .run(Expect.SUCCESS) .writeAll(); - checkForProcessorMessage(javacResult, true); - checkForCompilerNote(javacResult, true); + checkForProcessorMessage(javacResult, false); + checkForCompilerNote(javacResult, false); } @Test @@ -239,7 +247,7 @@ public class TestNoteOnImplicitProcessing extends TestRunner { .run(Expect.SUCCESS) .writeAll(); - checkForProcessorMessage(javacResult, true); + checkForProcessorMessage(javacResult, false); checkForCompilerNote(javacResult, false); } @@ -254,7 +262,7 @@ public class TestNoteOnImplicitProcessing extends TestRunner { .run(Expect.SUCCESS) .writeAll(); - checkForProcessorMessage(javacResult, true); + checkForProcessorMessage(javacResult, false); checkForCompilerNote(javacResult, false); } @@ -317,7 +325,7 @@ public class TestNoteOnImplicitProcessing extends TestRunner { task.call(); - verifyMessages(out, compilerOut, true); + verifyMessages(out, compilerOut, false, false); } { @@ -329,7 +337,7 @@ public class TestNoteOnImplicitProcessing extends TestRunner { task.setProcessors(List.of(processor)); task.call(); - verifyMessages(out, compilerOut, false); + verifyMessages(out, compilerOut, false, true); } { @@ -339,7 +347,7 @@ public class TestNoteOnImplicitProcessing extends TestRunner { task.analyze(); - verifyMessages(out, compilerOut, true); + verifyMessages(out, compilerOut, false, false); } { @@ -353,16 +361,21 @@ public class TestNoteOnImplicitProcessing extends TestRunner { task.setProcessors(List.of(processor)); task.analyze(); - verifyMessages(out, compilerOut, false); + verifyMessages(out, compilerOut, false, true); } } finally { System.setOut(oldOut); } } - private void verifyMessages(ByteArrayOutputStream out, StringWriter compilerOut, boolean expectedNotePresent) { - if (!out.toString(StandardCharsets.UTF_8).contains("ImplicitProcTestProc run")) { - throw new RuntimeException("Expected processor message not printed"); + private void verifyMessages(ByteArrayOutputStream out, StringWriter compilerOut, boolean expectedNotePresent, + boolean processorRunExpected) { + boolean processorRun = out.toString(StandardCharsets.UTF_8).contains("ImplicitProcTestProc run"); + + if (processorRun != processorRunExpected) { + throw new RuntimeException(processorRunExpected ? + "Expected processor message not printed" : + "Unexpected processor message printed"); } out.reset();