GROOVY-11896: Support module import declarations

Author: paulk-asert

src/antlr/GroovyLexer.g4

@@ -456,6 +456,7 @@ LONG          : 'long';
 
 NATIVE        : 'native';
 NEW           : 'new';
+MODULE        : 'module';
 NON_SEALED    : 'non-sealed';
 PACKAGE       : 'package';
 PERMITS       : 'permits';

src/antlr/GroovyParser.g4

@@ -118,7 +118,7 @@ packageDeclaration
     ;
 
 importDeclaration
-    :   annotationsOpt IMPORT STATIC? qualifiedName (DOT MUL | AS alias=identifier)?
+    :   annotationsOpt IMPORT (STATIC | MODULE)? qualifiedName (DOT MUL | AS alias=identifier)?
     ;
 
 
@@ -1230,6 +1230,7 @@ identifier
     |   CapitalizedIdentifier
     |   AS
     |   IN
+    |   MODULE
     |   PERMITS
     |   RECORD
     |   SEALED

src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java

@@ -338,9 +338,15 @@ public ImportNode visitImportDeclaration(final ImportDeclarationContext ctx) {
         List<AnnotationNode> annotations = this.visitAnnotationsOpt(ctx.annotationsOpt());
 
         boolean hasStatic = asBoolean(ctx.STATIC());
+        boolean hasModule = asBoolean(ctx.MODULE());
         boolean hasStar   = asBoolean(ctx.MUL());
         boolean hasAlias  = asBoolean(ctx.alias);
 
+        if (hasModule) {
+            String moduleName = this.visitQualifiedName(ctx.qualifiedName());
+            return expandModuleImport(moduleName, annotations, ctx);
+        }
+
         ImportNode importNode;
 
         if (hasStatic) {
@@ -387,6 +393,50 @@ public ImportNode visitImportDeclaration(final ImportDeclarationContext ctx) {
         return configureAST(importNode, ctx);
     }
 
+    /**
+     * Expands {@code import module java.base} into star imports for all
+     * packages exported (unqualified) by the named module.
+     * Packages already covered by Groovy's default imports or existing
+     * star imports are skipped to avoid redundant resolution work.
+     * <p>
+     * Known differences from Java's module import behavior:
+     * <ul>
+     * <li>Ambiguous class names from multiple module imports silently resolve
+     *     to the last match, consistent with Groovy's existing star import
+     *     semantics. Java reports a compile-time error for such ambiguities.</li>
+     * <li>Explicit single-type imports take priority over module-expanded
+     *     star imports (same as Java).</li>
+     * </ul>
+     */
+    private ImportNode expandModuleImport(final String moduleName, final List<AnnotationNode> annotations, final ImportDeclarationContext ctx) {
+        java.lang.module.ModuleFinder finder = java.lang.module.ModuleFinder.ofSystem();
+        java.lang.module.ModuleReference moduleRef = finder.find(moduleName).orElse(null);
+        if (moduleRef == null) {
+            throw createParsingFailedException("Unknown module: " + moduleName, ctx);
+        }
+        java.lang.module.ModuleDescriptor descriptor = moduleRef.descriptor();
+        java.util.Set<String> skip = new java.util.HashSet<>(java.util.Arrays.asList(
+                org.codehaus.groovy.control.ResolveVisitor.DEFAULT_IMPORTS));
+        moduleNode.getStarImports().stream().map(ImportNode::getPackageName).forEach(skip::add);
+        ImportNode lastImport = null;
+        for (java.lang.module.ModuleDescriptor.Exports export : descriptor.exports()) {
+            if (!export.isQualified()) {
+                String packageName = export.source() + DOT_STR;
+                if (!skip.contains(packageName)) {
+                    moduleNode.addStarImport(packageName, annotations);
+                    lastImport = last(moduleNode.getStarImports());
+                    skip.add(packageName);
+                }
+            }
+        }
+        if (lastImport == null) {
+            // All exported packages were already imported — add a no-op marker so AST is valid
+            moduleNode.addStarImport(org.codehaus.groovy.control.ResolveVisitor.DEFAULT_IMPORTS[0], annotations);
+            lastImport = last(moduleNode.getStarImports());
+        }
+        return configureAST(lastImport, ctx);
+    }
+
     private static AnnotationNode makeAnnotationNode(final Class<? extends Annotation> type) {
         AnnotationNode node = new AnnotationNode(ClassHelper.make(type));
         // TODO: source offsets

src/test/groovy/groovy/ImportTest.groovy

@@ -163,4 +163,58 @@ final class ImportTest {
             Entry entry = [foo:'bar'].entrySet().first()
         '''
     }
+
+    // module imports
+
+    @Test
+    void testImportModuleJavaBase() {
+        assertScript '''
+            import module java.base
+
+            // java.util
+            List list = [1, 2, 3]
+            Map map = [a: 1]
+
+            // java.io
+            File f = new File('.')
+
+            // java.net
+            URI uri = new URI('http://example.com')
+
+            // java.time
+            LocalDate date = LocalDate.now()
+
+            // java.util.concurrent
+            CountDownLatch latch = new CountDownLatch(1)
+
+            assert list.size() == 3
+        '''
+    }
+
+    @Test
+    void testImportModuleJavaSql() {
+        assertScript '''
+            import module java.sql
+
+            // java.sql package
+            assert Connection != null
+            assert DriverManager != null
+        '''
+    }
+
+    @Test
+    void testImportModuleUnknown() {
+        shouldFail '''
+            import module no.such.module
+        '''
+    }
+
+    @Test
+    void testModuleAsIdentifier() {
+        // 'module' can still be used as a variable name
+        assertScript '''
+            def module = 'hello'
+            assert module.toUpperCase() == 'HELLO'
+        '''
+    }
 }