[ 
https://issues.apache.org/jira/browse/GROOVY-11896?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=18072491#comment-18072491
 ] 

ASF GitHub Bot commented on GROOVY-11896:
-----------------------------------------

paulk-asert commented on code in PR #2429:
URL: https://github.com/apache/groovy/pull/2429#discussion_r3061808251


##########
src/main/java/org/apache/groovy/parser/antlr4/AstBuilder.java:
##########
@@ -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>

Review Comment:
   Yes, existing star imports includes package-private while Java doesn't. I 
created GROOVY-11916 in case we want to change that. I think it is okay to 
follow existing Groovy behavior and change it in GROOVY-11916 if we don't like 
that. I am not sure we document that difference for star imports. But we should 
do for both the same way. I'll await thoughts on GROOVY-11916 before making 
changes here.





> Support module import declarations
> ----------------------------------
>
>                 Key: GROOVY-11896
>                 URL: https://issues.apache.org/jira/browse/GROOVY-11896
>             Project: Groovy
>          Issue Type: New Feature
>            Reporter: Paul King
>            Assignee: Paul King
>            Priority: Major
>
> In Java, _module import declarations_ allow you to import all exported 
> packages of a module with a single statement. It was introduced as a preview 
> feature in Java 23 ([JEP 476|https://openjdk.org/jeps/476]) and finalized in 
> Java 25 ([JEP 511|https://openjdk.org/jeps/511]).
> The syntax is as follows:
> {code:java}
> import module java.base;    // Java
> {code}
> h3. Implementation highlights
> *  Grammar extended with a dedicated import module <qualifiedName> 
> alternative (no .* or as alias — rejected at parse time)                      
>                                                                               
>                  
> *  Modules resolved via ModuleFinder.compose(ofSystem(), 
> classpathModuleFinder()) — system/JDK modules first, then modular JARs on the 
> compilation classpath                                                         
>                              
> *  Explicit JPMS modules (with module-info.class) import all unqualified 
> exports; automatic modules (with Automatic-Module-Name manifest entry) import 
> all packages                                                                  
>              
> *   Default imports and existing star imports are skipped to avoid redundant 
> resolution                                                                    
>                                                                               
>           
> *   module remains usable as an identifier (context-sensitive keyword, like 
> record/sealed)                                                                
>                                                                               
>            
> Passing test scenarios:
> {code}                                                                        
>                                                                               
>                                                                               
>                
>   // System module — JDK classes available without individual imports
>   import module java.base                                                     
>                                                                               
>                                                                               
>          
>   LocalDate date = LocalDate.now()
>   CountDownLatch latch = new CountDownLatch(1)                                
>                                                                               
>                                                                               
>          
>                                                             
>   // System module — java.sql                                                 
>                                                                               
>                                                                               
>          
>   import module java.sql                                    
>   assert Connection.name == 'java.sql.Connection'                             
>                                                                               
>                                                                               
>          
>   assert DriverManager.name == 'java.sql.DriverManager'     
>                                                                               
>                                                                               
>                                                                               
>          
>   // JPMS module from classpath (module-info.class)                           
>                                                                               
>                                                                               
>          
>   import module org.junit.jupiter.api                                         
>                                                                               
>                                                                               
>          
>   assert Test.name == 'org.junit.jupiter.api.Test'                            
>                                                                               
>                                                                               
>          
>   assert DisabledIf.name == 'org.junit.jupiter.api.condition.DisabledIf'
>                                                                               
>                                                                               
>                                                                               
>          
>   // Automatic module from classpath (Automatic-Module-Name in MANIFEST.MF)   
>                                                                               
>                                                                               
>          
>   import module org.apache.groovy.jmx                                         
>                                                                               
>                                                                               
>          
>   assert GroovyMBean.name == 'groovy.jmx.GroovyMBean'                         
>                                                                               
>                                                                               
>          
>                                                                               
>                                                                               
>                                                                               
>          
>   // Unknown module — compile error
>   import module no.such.module  // fails: "Unknown module: no.such.module"    
>                                                                               
>                                                                               
>          
>                                                                               
>                                                                               
>                                                                               
>          
>   // Star/alias not permitted with module imports — parse error               
>                                                                               
>                                                                               
>          
>   import module java.base.*     // fails                                      
>                                                                               
>                                                                               
>          
>   import module java.base as jb // fails                                      
>                                                                               
>                                                                               
>          
>                                                                               
>                                                                               
>                                                                               
>          
>   // 'module' still works as an identifier
>   def module = 'hello'                                                        
>                                                                               
>                                                                               
>          
>   assert module.toUpperCase() == 'HELLO'
> {code}



--
This message was sent by Atlassian Jira
(v8.20.10#820010)

Reply via email to