GROOVY-11896: Support module import declarations

paulk-asert · paulk-asert · commit 174e2f2023ca · 2026-04-10T13:11:35.000+10:00
diff --git a/src/antlr/GroovyLexer.g4 b/src/antlr/GroovyLexer.g4
@@ -454,6 +454,7 @@ INT           : 'int';
 fragment
 LONG          : 'long';
 
+MODULE        : 'module';
 NATIVE        : 'native';
 NEW           : 'new';
 NON_SEALED    : 'non-sealed';
diff --git a/src/antlr/GroovyParser.g4 b/src/antlr/GroovyParser.g4
@@ -119,6 +119,7 @@ packageDeclaration
 
 importDeclaration
     :   annotationsOpt IMPORT STATIC? qualifiedName (DOT MUL | AS alias=identifier)?
+    |   annotationsOpt IMPORT MODULE qualifiedName
     ;
 
 
@@ -1230,6 +1231,7 @@ identifier
     |   CapitalizedIdentifier
     |   AS
     |   IN
+    |   MODULE
     |   PERMITS
     |   RECORD
     |   SEALED
diff --git a/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java b/src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java
@@ -136,18 +136,31 @@
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.lang.annotation.Annotation;
+import java.lang.module.FindException;
+import java.lang.module.ModuleDescriptor;
+import java.lang.module.ModuleFinder;
+import java.lang.module.ModuleReference;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Deque;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.Set;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
@@ -337,6 +350,11 @@ public PackageNode visitPackageDeclaration(final PackageDeclarationContext ctx)
     public ImportNode visitImportDeclaration(final ImportDeclarationContext ctx) {
         List<AnnotationNode> annotations = this.visitAnnotationsOpt(ctx.annotationsOpt());
 
+        if (asBoolean(ctx.MODULE())) {
+            String moduleName = this.visitQualifiedName(ctx.qualifiedName());
+            return expandModuleImport(moduleName, annotations, ctx);
+        }
+
         boolean hasStatic = asBoolean(ctx.STATIC());
         boolean hasStar   = asBoolean(ctx.MUL());
         boolean hasAlias  = asBoolean(ctx.alias);
@@ -387,6 +405,97 @@ 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>
+     * Modules are located from system modules (JDK) first, then from
+     * modular JARs on the compilation classpath. Automatic modules
+     * (JARs with an {@code Automatic-Module-Name} manifest entry but no
+     * {@code module-info.class}) are supported — all packages in the JAR
+     * are imported since automatic modules have no explicit exports.
+     * <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) {
+        ModuleFinder finder = ModuleFinder.compose(
+                ModuleFinder.ofSystem(), classpathModuleFinder());
+        ModuleReference moduleRef = finder.find(moduleName).orElse(null);
+        if (moduleRef == null) {
+            throw createParsingFailedException("Unknown module: " + moduleName, ctx);
+        }
+        ModuleDescriptor descriptor = moduleRef.descriptor();
+        Set<String> skip = new HashSet<>(Arrays.asList(
+                org.codehaus.groovy.control.ResolveVisitor.DEFAULT_IMPORTS));
+        moduleNode.getStarImports().stream().map(ImportNode::getPackageName).forEach(skip::add);
+        ImportNode lastImport = null;
+        // Automatic modules have no exports — use packages() instead
+        Collection<String> packageNames = descriptor.isAutomatic()
+                ? descriptor.packages()
+                : descriptor.exports().stream()
+                    .filter(e -> !e.isQualified())
+                    .map(ModuleDescriptor.Exports::source)
+                    .collect(Collectors.toList());
+        for (String pkg : packageNames) {
+            String packageName = pkg + 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 covered by existing imports
+            lastImport = last(moduleNode.getStarImports());
+        }
+        return configureAST(lastImport, ctx);
+    }
+
+    /**
+     * Builds a {@link java.lang.module.ModuleFinder} that scans the compilation
+     * classpath for modular JARs (those containing {@code module-info.class}).
+     * Collects paths from both the compiler configuration classpath and any
+     * URLClassLoaders in the classloader hierarchy.
+     */
+    private ModuleFinder classpathModuleFinder() {
+        Set<Path> paths = new LinkedHashSet<>();
+        for (String entry : sourceUnit.getConfiguration().getClasspath()) {
+            Path p = Path.of(entry);
+            if (java.nio.file.Files.exists(p)) {
+                paths.add(p);
+            }
+        }
+        ClassLoader cl = sourceUnit.getClassLoader();
+        while (cl != null) {
+            if (cl instanceof URLClassLoader) {
+                for (URL url : ((URLClassLoader) cl).getURLs()) {
+                    try {
+                        Path p = Path.of(url.toURI());
+                        if (java.nio.file.Files.exists(p)) {
+                            paths.add(p);
+                        }
+                    } catch (URISyntaxException ignore) {
+                    }
+                }
+            }
+            cl = cl.getParent();
+        }
+        try {
+            return ModuleFinder.of(paths.toArray(Path[]::new));
+        } catch (java.lang.module.FindException e) {
+            return ModuleFinder.of();
+        }
+    }
+
     private static AnnotationNode makeAnnotationNode(final Class<? extends Annotation> type) {
         AnnotationNode node = new AnnotationNode(ClassHelper.make(type));
         // TODO: source offsets
diff --git a/src/test/groovy/groovy/ImportTest.groovy b/src/test/groovy/groovy/ImportTest.groovy
@@ -163,4 +163,91 @@ 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.name == 'java.sql.Connection'
+            assert DriverManager.name == 'java.sql.DriverManager'
+        '''
+    }
+
+    @Test
+    void testImportModuleFromClasspath() {
+        // Find JUnit JAR from the test classloader and add it to the compiler classpath
+        def junitUrl = Test.class.protectionDomain.codeSource.location
+        def config = new org.codehaus.groovy.control.CompilerConfiguration()
+        config.classpathList = [new File(junitUrl.toURI()).path]
+        def loader = new GroovyClassLoader(getClass().classLoader, config)
+        def shell = new GroovyShell(loader)
+        shell.evaluate '''
+            import module org.junit.jupiter.api
+
+            // org.junit.jupiter.api package
+            assert Test.name == 'org.junit.jupiter.api.Test'
+            assert Assertions.name == 'org.junit.jupiter.api.Assertions'
+            assert DisplayName.name == 'org.junit.jupiter.api.DisplayName'
+            assert DisabledIf.name == 'org.junit.jupiter.api.condition.DisabledIf'
+        '''
+    }
+
+    @Test
+    void testImportModuleUnknown() {
+        shouldFail '''
+            import module no.such.module
+        '''
+    }
+
+    @Test
+    void testImportModuleStarNotAllowed() {
+        shouldFail '''
+            import module java.base.*
+        '''
+    }
+
+    @Test
+    void testImportModuleAliasNotAllowed() {
+        shouldFail '''
+            import module java.base as jb
+        '''
+    }
+
+    @Test
+    void testModuleAsIdentifier() {
+        // 'module' can still be used as a variable name
+        assertScript '''
+            def module = 'hello'
+            assert module.toUpperCase() == 'HELLO'
+        '''
+    }
 }
diff --git a/subprojects/groovy-jmx/build.gradle b/subprojects/groovy-jmx/build.gradle
@@ -32,3 +32,8 @@ dependencies {
     testRuntimeOnly projects.groovyGrapeIvy
     testRuntimeOnly projects.groovySwing
 }
+
+tasks.named('test') {
+    dependsOn 'jarjar'
+    systemProperty 'groovy.jmx.jar', tasks.named('jarjar').flatMap { it.outputFile }.get().asFile.path
+}
diff --git a/subprojects/groovy-jmx/src/test/groovy/groovy/jmx/ImportModuleJmxTest.groovy b/subprojects/groovy-jmx/src/test/groovy/groovy/jmx/ImportModuleJmxTest.groovy
@@ -0,0 +1,43 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+package groovy.jmx
+
+import org.junit.jupiter.api.Test
+
+import static groovy.test.GroovyAssert.assertScript
+
+final class ImportModuleJmxTest {
+
+    @Test
+    void testImportModuleAutomatic() {
+        // groovy-jmx is an automatic module (Automatic-Module-Name in MANIFEST.MF);
+        // JAR path is passed as a system property from build.gradle
+        def jmxJar = System.getProperty('groovy.jmx.jar')
+        assert jmxJar, 'groovy.jmx.jar system property not set'
+        def config = new org.codehaus.groovy.control.CompilerConfiguration()
+        config.classpathList = [jmxJar]
+        def loader = new GroovyClassLoader(getClass().classLoader, config)
+        def shell = new GroovyShell(loader)
+        shell.evaluate '''
+            import module org.apache.groovy.jmx
+
+            assert GroovyMBean.name == 'groovy.jmx.GroovyMBean'
+        '''
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -32,3 +32,8 @@ dependencies {`
`32`	`32`	`testRuntimeOnly projects.groovyGrapeIvy`
`33`	`33`	`testRuntimeOnly projects.groovySwing`
`34`	`34`	`}`
	`35`	`+`
	`36`	`+tasks.named('test') {`
	`37`	`+ dependsOn 'jarjar'`
	`38`	`+ systemProperty 'groovy.jmx.jar', tasks.named('jarjar').flatMap { it.outputFile }.get().asFile.path`
	`39`	`+}`