8224228: No way to locally suppress lint warnings in parser/tokenizer or preview features

src/jdk.compiler/share/classes/com/sun/tools/javac/parser/LexicalLintHandler.java

@@ -25,9 +25,10 @@
 
 package com.sun.tools.javac.parser;
 
-import java.util.ArrayDeque;
+import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.ListIterator;
+import java.util.concurrent.atomic.AtomicReference;
 
 import com.sun.tools.javac.code.DeferredLintHandler;
 import com.sun.tools.javac.code.DeferredLintHandler.LintLogger;
@@ -37,7 +38,6 @@
 import com.sun.tools.javac.util.Assert;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
 import com.sun.tools.javac.util.JCDiagnostic.LintWarning;
-import com.sun.tools.javac.util.JCDiagnostic.SimpleDiagnosticPosition;
 
 /**
  * Stashes lint warnings suppressible via {@code @SuppressWarnings} and their source code
@@ -51,10 +51,8 @@
 public class LexicalLintHandler {
 
     private final LinkedList<Report> reports = new LinkedList<>();
-    private final ArrayDeque<DeclNode> declNodes = new ArrayDeque<>();
+    private final ArrayList<DeclNode> declNodes = new ArrayList<>();
 
-    private int lastFlushedStartPos;
-    private int lastFlushedEndPos;
     private boolean flushed;
 
 // Public API
@@ -87,13 +85,29 @@ public void report(DiagnosticPosition pos, LintWarning key) {
      * @return the given {@code decl} (for fluent chaining)
      */
     public <T extends JCTree> T endDecl(T decl, int endPos) {
+
+        // Basic sanity checks
         Assert.check(!flushed);
         Assert.check(decl.getTag() == Tag.MODULEDEF
                   || decl.getTag() == Tag.PACKAGEDEF
                   || decl.getTag() == Tag.CLASSDEF
                   || decl.getTag() == Tag.METHODDEF
                   || decl.getTag() == Tag.VARDEF);
-        declNodes.addLast(new DeclNode(decl, endPos));
+
+        // Create new declaration node
+        DeclNode declNode = new DeclNode(decl, endPos);
+
+        // Verify our assumptions about declarations:
+        //  1. If two declarations overlap, then one of them must nest within the other
+        //  2. endDecl() is invoked in order of increasing declaration ending position
+        if (!declNodes.isEmpty()) {
+            DeclNode prevNode = declNodes.get(declNodes.size() - 1);
+            Assert.check(declNode.endPos() >= prevNode.endPos());
+            Assert.check(declNode.startPos() >= prevNode.endPos() || declNode.startPos() <= prevNode.startPos());
+        }
+
+        // Add node to the list
+        declNodes.add(declNode);
         return decl;
     }
 
@@ -109,13 +123,33 @@ public void flushTo(DeferredLintHandler deferredLintHandler) {
         Assert.check(!flushed);
         flushed = true;
 
-        // Flush reports contained within any of the declaration nodes we have gathered
-        declNodes.forEach(declNode -> flushDeclReports(deferredLintHandler, declNode));
-        declNodes.clear();
+        // Assign the innermost containing declaration, if any, to each report
+        ListIterator<Report> reportIterator = reports.listIterator(0);
+      declLoop:
+        for (DeclNode declNode : declNodes) {
+            while (true) {
+                if (!reportIterator.hasNext())
+                    break declLoop;
+                Report report = reportIterator.next();
+                switch (report.relativeTo(declNode)) {
+                case BEFORE:        // report is contained by some outer declaration, or is "top level"
+                    continue;
+                case WITHIN:        // assign to this declaration, unless contained by an inner declaration
+                    report.decl().compareAndSet(null, declNode.decl());
+                    continue;
+                case AFTER:         // we've gone too far, backup one step and go to the next declaration
+                    reportIterator.previous();
+                    continue declLoop;
+                }
+            }
+        }
 
-        // Flush the remaining reports, which must be "top level" (i.e., not contained within any declaration)
-        reports.forEach(report -> flushReport(deferredLintHandler, report));
+        // Now flush all the reports
+        reports.forEach(report -> report.flushTo(deferredLintHandler));
+
+        // Clean up
         reports.clear();
+        declNodes.clear();
     }
 
 // Internal Methods
@@ -134,73 +168,45 @@ private void addReport(Report report) {
         i.add(report);
     }
 
-    // Flush all reports contained within the given declaration
-    private void flushDeclReports(DeferredLintHandler deferredLintHandler, DeclNode declNode) {
-
-        // Get declaration's starting position so we know its lexical range
-        int startPos = TreeInfo.getStartPos(declNode.decl());
-        int endPos = declNode.endPos();
-
-        // Sanity check our assumptions about declarations:
-        //  1. If two declarations overlap, then one of them must nest within the other
-        //  2. endDecl() is always invoked in order of increasing declaration ending position
-        Assert.check(endPos >= lastFlushedEndPos);
-        Assert.check(startPos >= lastFlushedEndPos || startPos <= lastFlushedStartPos);
+// DeclNode
 
-        // Find all reports contained by the declaration; they should all be at or near the end of the list
-        ListIterator<Report> i = reports.listIterator(reports.size());
-        int count = 0;
-        while (i.hasPrevious()) {
-            switch (i.previous().compareToRange(startPos, endPos)) {
-            case AFTER:     // unusual; e.g., report is contained in the next token after declaration
-                continue;
-            case WITHIN:    // report is contained in the declaration, so we will flush it
-                count++;
-                continue;
-            case BEFORE:    // we've gone too far, backup one step and start here
-                i.next();
-                break;
-            }
-            break;
-        }
+    // A declaration that has been created and whose starting and ending positions are known
+    private record DeclNode(JCTree decl, int startPos, int endPos) {
 
-        // Flush the reports contained by the declaration (in order). Note, we know that it is the innermost
-        // containing declaration because any more deeply nested declarations must have already been flushed
-        // by now; this follows from the above assumptions.
-        deferredLintHandler.push(declNode.decl());
-        try {
-            while (count-- > 0) {
-                flushReport(deferredLintHandler, i.next());
-                i.remove();
-            }
-        } finally {
-            deferredLintHandler.pop();
+        DeclNode(JCTree decl, int endPos) {
+            this(decl, TreeInfo.getStartPos(decl), endPos);
         }
-
-        // Update markers
-        lastFlushedStartPos = startPos;
-        lastFlushedEndPos = endPos;
-    }
-
-    private void flushReport(DeferredLintHandler deferredLintHandler, Report report) {
-        deferredLintHandler.report(report.logger());
     }
 
-// DeclNode
-
-    // A declaration that has been created and whose starting and ending positions are known
-    private record DeclNode(JCTree decl, int endPos) { }
-
 // Report
 
     // A warning report that has not yet been flushed to the DeferredLintHandler
-    private record Report(int pos, LintLogger logger) {
+    private record Report(int pos, LintLogger logger, AtomicReference<JCTree> decl) {
+
+        Report(int pos, LintLogger logger) {
+            this(pos, logger, new AtomicReference<>());
+        }
+
+        // Flush this report to the DeferredLintHandler using our assigned declaration (if any)
+        void flushTo(DeferredLintHandler deferredLintHandler) {
+            JCTree decl = decl().get();
+            if (decl != null)
+                deferredLintHandler.push(decl);
+            try {
+                deferredLintHandler.report(logger());
+            } finally {
+                if (decl != null)
+                    deferredLintHandler.pop();
+            }
+        }
 
-        // Compare our position to the given range
-        Direction compareToRange(int minPos, int maxPos) {
-            if (pos() < minPos)
+        // Determine our position relative to the range spanned by the given declaration
+        Direction relativeTo(DeclNode declNode) {
+            int startPos = declNode.startPos();
+            int endPos = declNode.endPos();
+            if (pos() < startPos)
                 return Direction.BEFORE;
-            if (pos() == minPos || (pos() > minPos && pos() < maxPos)) {
+            if (pos() == startPos || (pos() > startPos && pos() < endPos)) {
                 return Direction.WITHIN;
             }
             return Direction.AFTER;

test/langtools/tools/javac/diags/examples/ImplicitClassBad-Filename.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 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
@@ -22,6 +22,8 @@
  */
 
  // key: compiler.err.bad.file.name
+ // key: compiler.note.preview.filename
+ // key: compiler.note.preview.recompile
  // options: -source ${jdk.version} --enable-preview
 
 public static void main(String... args) {

test/langtools/tools/javac/diags/examples/ImplicitClassHasPackage.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 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
@@ -22,6 +22,8 @@
  */
 
  // key: compiler.err.implicit.class.should.not.have.package.declaration
+ // key: compiler.note.preview.filename
+ // key: compiler.note.preview.recompile
  // options: -source ${jdk.version} --enable-preview
 
 package implicit.classes;

test/langtools/tools/javac/lint/LexicalLintNesting.java

@@ -0,0 +1,170 @@
+/*
+ * @test /nodynamiccopyright/
+ * @bug 8224228
+ * @summary Verify lexical lint warnings handle nested declarations with SuppressWarnings correctly
+ * @compile/fail/ref=LexicalLintNesting.out -XDrawDiagnostics -Xlint:text-blocks -Werror LexicalLintNesting.java
+ */
+
+//@SuppressWarnings("text-blocks")
+public class LexicalLintNesting {
+
+    //@SuppressWarnings("text-blocks")
+    /* WARNING HERE */ String s1 = """
+        trailing space here:\u0020
+        """;
+
+    @SuppressWarnings("text-blocks")
+    String s2 = """
+        trailing space here:\u0020
+        """;
+
+    //@SuppressWarnings("text-blocks")
+    public static class Nested1 {
+
+        @SuppressWarnings("text-blocks")
+        String s3 = """
+            trailing space here:\u0020
+            """;
+
+        //@SuppressWarnings("text-blocks")
+        /* WARNING HERE */ String s4 = """
+            trailing space here:\u0020
+            """;
+
+        @SuppressWarnings("text-blocks")
+        public static class Nested1A {
+
+            //@SuppressWarnings("text-blocks")
+            String s5 = """
+                trailing space here:\u0020
+                """;
+
+            @SuppressWarnings("text-blocks")
+            String s6 = """
+                trailing space here:\u0020
+                """;
+
+        }
+
+        @SuppressWarnings("text-blocks")
+        String s7 = """
+            trailing space here:\u0020
+            """;
+
+        //@SuppressWarnings("text-blocks")
+        /* WARNING HERE */ String s8 = """
+            trailing space here:\u0020
+            """;
+
+        //@SuppressWarnings("text-blocks")
+        public static class Nested1B {
+
+            @SuppressWarnings("text-blocks")
+            String s9 = """
+                trailing space here:\u0020
+                """;
+
+            //@SuppressWarnings("text-blocks")
+            /* WARNING HERE */ String s10 = """
+                trailing space here:\u0020
+                """;
+
+        }
+
+        @SuppressWarnings("text-blocks")
+        String s11 = """
+            trailing space here:\u0020
+            """;
+
+        //@SuppressWarnings("text-blocks")
+        /* WARNING HERE */ String s12 = """
+            trailing space here:\u0020
+            """;
+
+    }
+
+    @SuppressWarnings("text-blocks")
+    String s13 = """
+        trailing space here:\u0020
+        """;
+
+    //@SuppressWarnings("text-blocks")
+    /* WARNING HERE */ String s14 = """
+        trailing space here:\u0020
+        """;
+
+    @SuppressWarnings("text-blocks")
+    public static class Nested2 {
+
+        @SuppressWarnings("text-blocks")
+        String s15 = """
+            trailing space here:\u0020
+            """;
+
+        //@SuppressWarnings("text-blocks")
+        String s16 = """
+            trailing space here:\u0020
+            """;
+
+        @SuppressWarnings("text-blocks")
+        public static class Nested2A {
+
+            //@SuppressWarnings("text-blocks")
+            String s17 = """
+                trailing space here:\u0020
+                """;
+
+            @SuppressWarnings("text-blocks")
+            String s18 = """
+                trailing space here:\u0020
+                """;        // SHOULD NOT get a warning here
+
+        }
+
+        @SuppressWarnings("text-blocks")
+        String s19 = """
+            trailing space here:\u0020
+            """;
+
+        //@SuppressWarnings("text-blocks")
+        String s20 = """
+            trailing space here:\u0020
+            """;
+
+        //@SuppressWarnings("text-blocks")
+        public static class Nested2B {
+
+            @SuppressWarnings("text-blocks")
+            String s21 = """
+                trailing space here:\u0020
+                """;
+
+            //@SuppressWarnings("text-blocks")
+            String s22 = """
+                trailing space here:\u0020
+                """;
+
+        }
+
+        @SuppressWarnings("text-blocks")
+        String s23 = """
+            trailing space here:\u0020
+            """;
+
+        //@SuppressWarnings("text-blocks")
+        String s24 = """
+            trailing space here:\u0020
+            """;
+
+    }
+
+    //@SuppressWarnings("text-blocks")
+    /* WARNING HERE */ String s25 = """
+        trailing space here:\u0020
+        """;
+
+    @SuppressWarnings("text-blocks")
+    String s26 = """
+        trailing space here:\u0020
+        """;
+}

test/langtools/tools/javac/lint/LexicalLintNesting.out

@@ -0,0 +1,10 @@
+LexicalLintNesting.java:12:36: compiler.warn.trailing.white.space.will.be.removed
+LexicalLintNesting.java:30:40: compiler.warn.trailing.white.space.will.be.removed
+LexicalLintNesting.java:55:40: compiler.warn.trailing.white.space.will.be.removed
+LexicalLintNesting.java:68:45: compiler.warn.trailing.white.space.will.be.removed
+LexicalLintNesting.java:80:41: compiler.warn.trailing.white.space.will.be.removed
+LexicalLintNesting.java:92:37: compiler.warn.trailing.white.space.will.be.removed
+LexicalLintNesting.java:162:37: compiler.warn.trailing.white.space.will.be.removed
+- compiler.err.warnings.and.werror
+1 error
+7 warnings