Add module-info.java

[hrchu]

So that projects depend on this can be published to a public artifact repository.
Note that this is not breaking backward compatibility. All codes except this file can be still compiled in Java 6.

[jbduncan]

Guava has an Automatic-Module-Name in its MANIFEST.MF now, so I believe this is not quite as important as it may seem. But if I'm mistaken, then I'd be more than happy to be proven wrong.

(BTW, I think I might have misunderstood something, because module-info.java is Java 9 specific, right? Would a Java 8 compiler (which I believe is what is used to compile guava-jre) or an Android compiler (for guava-android) happily process it or otherwise ignore it?)

[cpovirk]

Our current thinking is that we'll look into this next quarter. We have seen some problems from module-info files in third-party jars, since they're Java 9 .class files and not everyone uses Java 9 yet. So, if we can get away with Automatic-Module-Name, we'll continue to do so, possibly even beyond next quarter. But if there are cases in which Automatic-Module-Name isn't good enough, that would be good to know.

[hrchu]

It is possible to only compile modile-info.java in Java 9, so the jar file is still compatible to users who uses earlier Java version.

A maven example:
https://github.com/twonote/radosgw-admin4j/blob/java9/pom.xml#L127

[cpovirk]

Right, thanks. We've seen problems even when the main .class files are compiled for an older version but the module-info.class is present. As I understand it, various tools try to process all .class files, and they need to be updated to ignore module-info.class.

[hrchu]

@cpovirk could you tell me more about this problem?

[cpovirk]

I wasn't personally involved in fixing the problems, but the basic idea seems to be that people scan the whole classpath (using something like ClassPath.getTopLevelClasses -- which might be an example of something that needs updated to ignore module-info.class :)) and then try to examine/load the classes with a tool that understands only, say, Java 8.

[orionll]

It's worth mentioning that if we add module-info.java, all packages will not be open anymore.

[jbduncan]

@orionll Am I right to think/remember that in the JPMS, open packages are packages whose internal classes can be inspected with reflection?

[orionll]

@jbduncat Yes, exactly. And also private members of public classes.

[jbduncan]

@orionll Cool, thanks for confirming things for me. :)

I personally wonder how important it would be for Guava's packages to be open when used on the module path. I struggle to imagine that reflectively calling Guava's internals is a common thing to do, especially considering Guava's (IMO) pretty durn good API. 🤔

[HoldYourWaffle]

Are there any reasons for it not being open? Even if it's uncommon it might still be done by some people.

[jbduncan]

@HoldYourWaffle I think the main reason is it prevents people from using reflection to depend on internals which may change or disappear in future releases of Guava without warning.

[jbduncan]

...which by my understanding makes things easier for everyone in the long-run.

[jbduncan]

The only reason I can currently think of to have Guava's packages open in the module-info.java is if frameworks like Spring need to reflectively access its internals to do important stuff, but I don't know how important or common that is.

[orionll]

All Guava packages should be closed because as @jbduncan said the dependence on class internals is a bad practice. If someone really wants to access the internals, they can use --add-opens command line option which forces the specified package to be open.

[HoldYourWaffle]

Good point I forgot about --add-opens. Imho you should always be able to hack into internals (maybe you want to do something the developers didn't think of but it's too 'personal' that it's not worthy of a PR), with the risk of it breaking in new versions. --add-opens allows for this so it'd indeed be better to close the guava packages.

[SamCarlberg]

Guava has an Automatic-Module-Name in its MANIFEST.MF now, so I believe this is not quite as important as it may seem. But if I'm mistaken, then I'd be more than happy to be proven wrong.

It does mean that jlink will not work, since the tool requires a module name to be specified in the module-info.java file; automatic module names will not be accepted.

[hannes-transentials]

As much as I love Guava and appreciate Google's efforts, it is somehow embarrassing that a company like Google is not able to adopt Java modules within one year.

Either Google does not use Guava internally or they keep using JDK 8 and won't adopt Jigsaw.

[jbduncan]

@hannes-transentials I think it's most likely that Google have not migrated to JDK 11 and adopted modules yet simply because their internal codebase is so mind-bogglingly humongous. ;)

I say this because I remember reading somewhere (or I inferred) that they use Guava or an superset internally, and I also remember they announced a few years ago that they'd finally migrated to JDK 8 after a lot of effort. So I'm sure that they'll announce support for JDK 11 or a later LTS version (and, by extension, modules) when they fully migrate away from Java 8 and when they feel that most of us non-Googlers have moved away from Java 8 too. (I know that my company hasn't done so yet simply because Java 9 was such a freaking big, backwards-incompatible change!)

[orionll]

It's worth mentioning that adding module-info.java can break some existing tools. For example, I know that IDEA's Osmorc plugin does not work when both module-info.java exists and the library is an OSGi bundle (Guava is). So, while the tools are not ready yet, I would abstain from adding module-info.java to Guava.

[hannes-transentials]

So I either do without modularized applications or stay away from Guava (and many other popular applications)? I somehow hoped that there was some middle ground.

[jbduncan]

Well... you can use Guava as a module in a vanilla-Java modular application. But since Guava only includes an Automatic-Module-Name in its manifest, rather than going further and including amodule.info (out of necessity to stay Java-8-compatible), you won't be able to use it with jlink to create minimised modular Java applications.

Furthermore, frameworks built on top of Java that have their own programming models, like Spring, may have not fully migrated to be Java-11-compatible yet, so if you use such frameworks a lot, you may have to wait a bit longer.

That being said, if you do use a framework such a Spring, please check for yourself if Java 11 and modules work with it, since my knowledge of Spring and other frameworks is limited. :)

[overheadhunter]

out of necessity to stay Java-8-compatible

Well you can create multi-release jars, where the module-info.class file only gets included inside META-INF/versions/9 and is therefore invisible for old¹ class loaders.

---

¹ As long as no fancy custom class loaders eagerly load everything they find in a jar without reading the manifest entries.

[talios]

@hannes-transentials You could make use of something like https://github.com/moditect/moditect to adapt guava and add a module-info.java/.class at your applications side of things as a transitionary work around.

If module-info.java was to be added to guava, hopefully it'd be done so as a modular jar so we don't break java 8< versions.

[cowwoc]

I can't think of any problems with you depending on jdk.unsupported and removing it later. Go for it.

[sgammon]

@cpovirk I've been reworking this PR over the past 48 hours, and it is apparent to me that there are multiple approaches we could take with regard to JPMS compilation steps:

(1) Modify JPMS-enabled libs only. Additional compiler executions could be added to JPMS-enabled modules (non-Android guava, failureaccess, testlib), with defaults left alone in the top-level POM and elsewhere.

• This repeats some configuration for sure, but is probably less invasive for Android and GWT use cases
• The PR takes this approach now, but I wanted to try it against 2 for comparison

(2) Modify defaults and then non-JPMS libs. More targets are JPMS-enabled in this PR than not (the odd ones out are Android Guava, guava-gwt, and guava-test). So, maybe we set new defaults and override modules which do not need or cannot support JPMS.

• Initial investigation reveals that this might not reduce the size of the change by much
• We would have to get overrides exactly-right in the more exotic leaf libraries
• There are some complications down this route related to compile source roots -- JPMS wants them, but they preclude use of <exclude> etc., as I know you are aware from inline comments ;)

Any advice one way or the other? After investigating 2, I'm inclined to stick with 1, with extensive inline comments justifying why compiler flags are put where they are.

Current draft of these changes is here, although it is undergoing cleanup now and will trim down. Case 1 and 2 are both on the order of hundreds of lines, less than 500 for sure. We're talking about, like, 350 vs. 250 or somewhere in there in terms of lines added, mostly of POM XML:

The original PR weighs in much heavier:

So I think we are well on our way to a trim, potentially mergeable change.

cc / @cowwoc in case you want to weigh in

[sgammon]

Update: You can try the latest JPMS-enabled Guava here, in the JPMS attic repository. Add it to your Gradle or Maven build according to the directions, and then use the JPMS version of Guava with:

<dependency>
  <groupId>com.google.guava</groupId>
  <artifactId>guava</groupId>
  <version>33.4.0-jre-jpms</version>
</dependency>

dependencies {
  implementation("com.google.guava:guava:33.4.0-jre-jpms")
}

To force overrides transitively in Gradle:

configurations.all {
  resolutionStrategy.eachDependency {
    if (it.requested.group == "com.google.guava") {
      useVersion("33.4.0-jre-jpms")
      because("jpms support")
    }
  }
}

Several projects are passing integration tests, including Caffeine, GSON, Checkstyle, and others. I am using it already in downstream projects via Gradle with no issues.

[cpovirk]

I don't want to act like I would have foreseen this, but now that you say it, I find it very believable that (1) would turn out simpler. I skimmed the draft PR, and nothing in it immediately offended my delicate sensibilities, so that also seems like a good sign. I'm all ears if you or others end up with reasons to prefer (2) in the future, but (1) sounds fine to me.

[sgammon]

Cool :) once it is cleaned up and my mess of commits are squashed, I will update the attached PR (#7094) and push it again to the JPMS attic for testing.

[sgammon]

@cpovirk and others: PR #7094 is ready for review.