org.aspectj.org.eclipse.jdt.internal.compiler.lookup

Class ModuleBinding

java.lang.Object

org.aspectj.org.eclipse.jdt.internal.compiler.lookup.Binding

org.aspectj.org.eclipse.jdt.internal.compiler.lookup.ModuleBinding

All Implemented Interfaces:

IUpdatableModule

Direct Known Subclasses:

BinaryModuleBinding, ModuleBinding.UnNamedModule, SourceModuleBinding

public class ModuleBinding
extends Binding
implements IUpdatableModule

This class serves a dual purpose

First, it canonically represents modules in the world of bindings.

Secondly, it adds a graph layer on top of LookupEnvironment: ModuleBindins are linked through "read" edges as per JPMS (see java.lang.module.Configuration). Additionally, each ModuleBinding holds its own instance of LookupEnviroment, capturing all packages and types that are visible to the current module. As a subset of all visible types, the ModuleBinding knows the set of packages locally declared in this module.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ModuleBinding.UnNamedModule

Nested classes/interfaces inherited from interface org.aspectj.org.eclipse.jdt.internal.compiler.env.IUpdatableModule

IUpdatableModule.AddExports, IUpdatableModule.AddReads, IUpdatableModule.UpdateKind, IUpdatableModule.UpdatesByKind

Field Summary

Fields

Modifier and Type	Field and Description
static char[]	ALL_UNNAMED Name to represent unnamed modules in --add-exports & --add-reads options.
static char[]	ANY Module name for package/type lookup that doesn't care about modules.
static char[]	ANY_NAMED Module name for package/type lookup that should look into all named modules.
HashtableOfPackage<PlainPackageBinding>	declaredPackages Packages declared in this module (indexed by qualified name).
int	defaultNullness
LookupEnvironment	environment
protected PlainPackageBinding[]	exportedPackages
java.util.Map<TypeBinding,TypeBinding[]>	implementations
char[]	mainClassName
int	modifiers
char[]	moduleName
protected PlainPackageBinding[]	openedPackages
protected ModuleBinding[]	requires
protected ModuleBinding[]	requiresTransitive
protected TypeBinding[]	services
long	tagBits
static char[]	UNNAMED Name of the unnamed module.
static char[]	UNOBSERVABLE Module name for an unobservable module
protected TypeBinding[]	uses

Fields inherited from class org.aspectj.org.eclipse.jdt.internal.compiler.lookup.Binding

ANY_EXCEPTION, ARRAY_TYPE, BASE_TYPE, DefaultLocationArrayContents, DefaultLocationField, DefaultLocationParameter, DefaultLocationReturnType, DefaultLocationsForTrueValue, DefaultLocationTypeArgument, DefaultLocationTypeBound, DefaultLocationTypeParameter, FIELD, GENERIC_TYPE, IMPORT, INTERSECTION_TYPE, INTERSECTION_TYPE18, LOCAL, METHOD, MODULE, NO_ANNOTATIONS, NO_ELEMENT_VALUE_PAIRS, NO_EXCEPTIONS, NO_FIELDS, NO_MEMBER_TYPES, NO_METHODS, NO_MODULES, NO_NULL_DEFAULT, NO_PACKAGES, NO_PARAMETER_NAMES, NO_PARAMETERS, NO_PLAIN_PACKAGES, NO_REFERENCE_TYPES, NO_SUPERINTERFACES, NO_TYPE_VARIABLES, NO_TYPES, NULL_UNSPECIFIED_BY_DEFAULT, NullnessDefaultMASK, PACKAGE, PARAMETERIZED_TYPE, POLY_TYPE, RAW_TYPE, TYPE, TYPE_PARAMETER, TYPE_USE, UNINITIALIZED_FIELDS, UNINITIALIZED_METHODS, UNINITIALIZED_REFERENCE_TYPES, VARIABLE, WILDCARD_TYPE

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	ModuleBinding(char[] moduleName, LookupEnvironment existingEnvironment)

Method Summary

Modifier and Type	Method and Description
void	addExports(char[] packageName, char[][] targetModules) Perform an --add-exports update on the module.
void	addReads(char[] requiredModuleName) Perform an --add-reads update on the module.
void	addResolvedExport(PlainPackageBinding declaredPackage, char[][] targetModules)
void	addResolvedOpens(PlainPackageBinding declaredPackage, char[][] targetModules)
boolean	canAccess(PackageBinding pkg) Check if the given package is accessible by this module.
char[]	computeUniqueKey(boolean isLeaf)
java.util.function.Supplier<java.util.Collection<ModuleBinding>>	dependencyCollector()
java.util.function.Supplier<java.util.Collection<ModuleBinding>>	dependencyGraphCollector()
ModuleBinding[]	getAllRequiredModules() Get all the modules required by this module All required modules include modules explicitly specified as required in the module declaration as well as implicit dependencies - those specified as ' requires transitive ' by one of the dependencies
int	getDefaultNullness()
java.lang.String[]	getExportRestrictions(PackageBinding pack)
PlainPackageBinding[]	getExports()
TypeBinding[]	getImplementations(TypeBinding binding)
java.lang.String[]	getOpenRestrictions(PackageBinding pack)
PlainPackageBinding[]	getOpens()
PlainPackageBinding	getOrCreateDeclaredPackage(char[][] compoundName)
char[][]	getPackageNamesForClassFile()
ModuleBinding[]	getRequires()
ModuleBinding[]	getRequiresTransitive()
TypeBinding[]	getServices()
PackageBinding	getTopLevelPackage(char[] name) Return a package binding if there exists a package named name in this module's context and it can be seen by this module.
TypeBinding[]	getUses()
PackageBinding	getVisiblePackage(char[][] qualifiedPackageName) Answer the package of the given qualified name and visible in this module, or null if no such package exists.
boolean	hasUnstableAutoName()
boolean	isDeprecated()
boolean	isOpen()
boolean	isPackageExportedTo(PackageBinding pkg, ModuleBinding client) Check if the specified package is owned by the current module and exported to the client module.
boolean	isTransitivelyRequired(ModuleBinding otherModule)
boolean	isUnnamed()
int	kind()
char[]	name() Answer the name of this module.
char[]	nameForCUCheck() Answer the name of this module as it should be used for hasCompilationUnit() checks.
char[]	nameForLookup() Answer the name of this module as it should be used for package or type lookup.
char[]	readableName()
protected void	recordExportRestrictions(PlainPackageBinding exportedPackage, char[][] targetModules)
protected void	recordOpensRestrictions(PlainPackageBinding openedPackage, char[][] targetModules)
AnnotationHolder	retrieveAnnotationHolder(Binding binding, boolean forceInitialization)
void	setAnnotations(AnnotationBinding[] annotations, boolean forceStore)
void	setMainClassName(char[] mainClassName) Define the ModuleMainClass to be recorded in the generated module-info.class.
void	setPackageNames(SimpleSetOfCharArray packageNames) Passes names of packages to be recorded in the ModulePackages classfile attribute.
java.lang.String	toString()

Methods inherited from class org.aspectj.org.eclipse.jdt.internal.compiler.lookup.Binding

computeUniqueKey, getAnnotations, getAnnotationTagBits, initializeDeprecatedAnnotationTagBits, isAnnotationType, isParameter, isTaggedRepeatable, isValid, isValidBinding, isVolatile, problemId, setAnnotations, shortReadableName

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

UNNAMED

public static final char[] UNNAMED

Name of the unnamed module.

ALL_UNNAMED

public static final char[] ALL_UNNAMED

Name to represent unnamed modules in --add-exports & --add-reads options.

ANY

public static final char[] ANY

Module name for package/type lookup that doesn't care about modules.

ANY_NAMED

public static final char[] ANY_NAMED

Module name for package/type lookup that should look into all named modules.

UNOBSERVABLE

public static final char[] UNOBSERVABLE

Module name for an unobservable module

moduleName

public char[] moduleName

requires

protected ModuleBinding[] requires

requiresTransitive

protected ModuleBinding[] requiresTransitive

exportedPackages

protected PlainPackageBinding[] exportedPackages

openedPackages

protected PlainPackageBinding[] openedPackages

uses

protected TypeBinding[] uses

services

protected TypeBinding[] services

implementations

public java.util.Map<TypeBinding,TypeBinding[]> implementations

mainClassName

public char[] mainClassName

modifiers

public int modifiers

environment

public LookupEnvironment environment

tagBits

public long tagBits

defaultNullness

public int defaultNullness

declaredPackages

public HashtableOfPackage<PlainPackageBinding> declaredPackages

Packages declared in this module (indexed by qualified name). We consider a package as declared in a module, if a compilation unit associated with the module declares the package or a subpackage thereof.

A package in this structures is always represented by a PlainPackageBinding, as opposed to SplitPackageBinding, which are only maintained in the trees below LookupEnvironment.knownPackages.

This structure is populated early during compilation with all packages that are referenced in exports and opens directives, plus their parent packages.

Constructor Detail

ModuleBinding

protected ModuleBinding(char[] moduleName,
                        LookupEnvironment existingEnvironment)

Method Detail

getExports

public PlainPackageBinding[] getExports()

getExportRestrictions

public java.lang.String[] getExportRestrictions(PackageBinding pack)

getOpens

public PlainPackageBinding[] getOpens()

getOpenRestrictions

public java.lang.String[] getOpenRestrictions(PackageBinding pack)

getImplementations

public TypeBinding[] getImplementations(TypeBinding binding)

getRequires

public ModuleBinding[] getRequires()

getRequiresTransitive

public ModuleBinding[] getRequiresTransitive()

getUses

public TypeBinding[] getUses()

getServices

public TypeBinding[] getServices()

addReads

public void addReads(char[] requiredModuleName)

Description copied from interface: IUpdatableModule

Perform an --add-reads update on the module.

Specified by:

addReads in interface IUpdatableModule

addExports

public void addExports(char[] packageName,
                       char[][] targetModules)

Description copied from interface: IUpdatableModule

Perform an --add-exports update on the module.

Specified by:

addExports in interface IUpdatableModule

setMainClassName

public void setMainClassName(char[] mainClassName)

Description copied from interface: IUpdatableModule

Define the ModuleMainClass to be recorded in the generated module-info.class.

Specified by:

setMainClassName in interface IUpdatableModule

setPackageNames

public void setPackageNames(SimpleSetOfCharArray packageNames)

Description copied from interface: IUpdatableModule

Passes names of packages to be recorded in the ModulePackages classfile attribute.

Specified by:

setPackageNames in interface IUpdatableModule

getPackageNamesForClassFile

public char[][] getPackageNamesForClassFile()

Returns:

array of names, which may contain nulls.

getOrCreateDeclaredPackage

public PlainPackageBinding getOrCreateDeclaredPackage(char[][] compoundName)

addResolvedExport

public void addResolvedExport(PlainPackageBinding declaredPackage,
                              char[][] targetModules)

addResolvedOpens

public void addResolvedOpens(PlainPackageBinding declaredPackage,
                             char[][] targetModules)

recordExportRestrictions

protected void recordExportRestrictions(PlainPackageBinding exportedPackage,
                                        char[][] targetModules)

recordOpensRestrictions

protected void recordOpensRestrictions(PlainPackageBinding openedPackage,
                                       char[][] targetModules)

dependencyGraphCollector

public java.util.function.Supplier<java.util.Collection<ModuleBinding>> dependencyGraphCollector()

dependencyCollector

public java.util.function.Supplier<java.util.Collection<ModuleBinding>> dependencyCollector()

getAllRequiredModules

public ModuleBinding[] getAllRequiredModules()

Get all the modules required by this module All required modules include modules explicitly specified as required in the module declaration as well as implicit dependencies - those specified as ' requires transitive ' by one of the dependencies

Returns:

An array of all required modules

name

public char[] name()

Answer the name of this module. The unnamed module is identified by UNNAMED.

Specified by:

name in interface IUpdatableModule

nameForLookup

public char[] nameForLookup()

Answer the name of this module as it should be used for package or type lookup. Unnamed and automatic modules answer ANY or ANY_NAMED resp., to signal that lookup should search in all accessible (named) modules.

nameForCUCheck

public char[] nameForCUCheck()

Answer the name of this module as it should be used for hasCompilationUnit() checks.

isPackageExportedTo

public boolean isPackageExportedTo(PackageBinding pkg,
                                   ModuleBinding client)

Check if the specified package is owned by the current module and exported to the client module. True if the package appears in the list of exported packages and when the export is targeted, the module appears in the targets of the exports statement.

Parameters:

pkg - - the package whose visibility is to be checked

client - - the module that wishes to use the package

Returns:

true if the package is visible to the client module, false otherwise

getTopLevelPackage

public PackageBinding getTopLevelPackage(char[] name)

Return a package binding if there exists a package named name in this module's context and it can be seen by this module. A package can be seen by this module if it is declared in this module or any other module read by this module (JLS 7.4.3 for packages based on JLS 7.3 for compilation units). Package exports are not considered for visibility check (only when checking "uniquely visible" (JLS 7.4.3)).

The returned package may be a SplitPackageBinding, if more than one package of the given name is visible.

When asked via the unnamed module or an automatic module all other named modules are considered visible.

getVisiblePackage

public PackageBinding getVisiblePackage(char[][] qualifiedPackageName)

Answer the package of the given qualified name and visible in this module, or null if no such package exists. Accessibility (based on package exports) is not checked.

May answer a SplitPackageBinding.

canAccess

public boolean canAccess(PackageBinding pkg)

Check if the given package is accessible by this module. True when the package is declared in this module or exported by some required module to this module. See isPackageExportedTo(PackageBinding, ModuleBinding)

Parameters:

pkg -

Returns:

True, if the package is accessible by this module, false otherwise

computeUniqueKey

public char[] computeUniqueKey(boolean isLeaf)

Overrides:

computeUniqueKey in class Binding

kind

public int kind()

Specified by:

kind in class Binding

readableName

public char[] readableName()

Specified by:

readableName in class Binding

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

isUnnamed

public boolean isUnnamed()

isOpen

public boolean isOpen()

isDeprecated

public boolean isDeprecated()

hasUnstableAutoName

public boolean hasUnstableAutoName()

isTransitivelyRequired

public boolean isTransitivelyRequired(ModuleBinding otherModule)

getDefaultNullness

public int getDefaultNullness()

retrieveAnnotationHolder

public AnnotationHolder retrieveAnnotationHolder(Binding binding,
                                                 boolean forceInitialization)

setAnnotations

public void setAnnotations(AnnotationBinding[] annotations,
                           boolean forceStore)

Overrides:

setAnnotations in class Binding