Packaging: Java refactoring

Split java pack into `codeql/java-all` and `codeql/java-queries`.

java/ql/lib/semmle/code/java/Modules.qll

@@ -0,0 +1,197 @@
+/**
+ * Provides classes for working with Java modules.
+ */
+
+import CompilationUnit
+
+/**
+ * A module.
+ */
+class Module extends @module {
+  Module() { modules(this, _) }
+
+  /**
+   * Gets the name of this module.
+   */
+  string getName() { modules(this, result) }
+
+  /**
+   * Holds if this module is an `open` module, that is,
+   * it grants access _at run time_ to types in all its packages,
+   * as if all packages had been exported.
+   */
+  predicate isOpen() { isOpen(this) }
+
+  /**
+   * Gets a directive of this module.
+   */
+  Directive getADirective() { directives(this, result) }
+
+  /**
+   * Gets a compilation unit associated with this module.
+   */
+  CompilationUnit getACompilationUnit() { cumodule(result, this) }
+
+  /** Gets a textual representation of this module. */
+  string toString() { modules(this, result) }
+}
+
+/**
+ * A directive in a module declaration.
+ */
+abstract class Directive extends @directive {
+  /** Gets a textual representation of this directive. */
+  abstract string toString();
+}
+
+/**
+ * A `requires` directive in a module declaration.
+ */
+class RequiresDirective extends Directive, @requires {
+  RequiresDirective() { requires(this, _) }
+
+  /**
+   * Holds if this `requires` directive is `transitive`,
+   * that is, any module that depends on this module
+   * has an implicitly declared dependency on the
+   * module specified in this `requires` directive.
+   */
+  predicate isTransitive() { isTransitive(this) }
+
+  /**
+   * Holds if this `requires` directive is `static`,
+   * that is, the dependence specified by this `requires`
+   * directive is only mandatory at compile time but
+   * optional at run time.
+   */
+  predicate isStatic() { isStatic(this) }
+
+  /**
+   * Gets the module on which this module depends.
+   */
+  Module getTargetModule() { requires(this, result) }
+
+  override string toString() {
+    exists(string transitive, string static |
+      (if isTransitive() then transitive = "transitive " else transitive = "") and
+      (if isStatic() then static = "static " else static = "")
+    |
+      result = "requires " + transitive + static + getTargetModule() + ";"
+    )
+  }
+}
+
+/**
+ * An `exports` directive in a module declaration.
+ */
+class ExportsDirective extends Directive, @exports {
+  ExportsDirective() { exports(this, _) }
+
+  /**
+   * Gets the package exported by this `exports` directive.
+   */
+  Package getExportedPackage() { exports(this, result) }
+
+  /**
+   * Holds if this `exports` directive is qualified, that is,
+   * it contains a `to` clause.
+   *
+   * For qualified `exports` directives, exported types and members
+   * are accessible only to code in the specified modules.
+   * For unqualified `exports` directives, they are accessible
+   * to code in any module.
+   */
+  predicate isQualified() { exportsTo(this, _) }
+
+  /**
+   * Gets a module specified in the `to` clause of this
+   * `exports` directive, if any.
+   */
+  Module getATargetModule() { exportsTo(this, result) }
+
+  override string toString() {
+    exists(string toClause |
+      if isQualified()
+      then toClause = (" to " + concat(getATargetModule().getName(), ", "))
+      else toClause = ""
+    |
+      result = "exports " + getExportedPackage() + toClause + ";"
+    )
+  }
+}
+
+/**
+ * An `opens` directive in a module declaration.
+ */
+class OpensDirective extends Directive, @opens {
+  OpensDirective() { opens(this, _) }
+
+  /**
+   * Gets the package opened by this `opens` directive.
+   */
+  Package getOpenedPackage() { opens(this, result) }
+
+  /**
+   * Holds if this `opens` directive is qualified, that is,
+   * it contains a `to` clause.
+   *
+   * For qualified `opens` directives, opened types and members
+   * are accessible only to code in the specified modules.
+   * For unqualified `opens` directives, they are accessible
+   * to code in any module.
+   */
+  predicate isQualified() { opensTo(this, _) }
+
+  /**
+   * Gets a module specified in the `to` clause of this
+   * `opens` directive, if any.
+   */
+  Module getATargetModule() { opensTo(this, result) }
+
+  override string toString() {
+    exists(string toClause |
+      if isQualified()
+      then toClause = (" to " + concat(getATargetModule().getName(), ", "))
+      else toClause = ""
+    |
+      result = "opens " + getOpenedPackage() + toClause + ";"
+    )
+  }
+}
+
+/**
+ * A `uses` directive in a module declaration.
+ */
+class UsesDirective extends Directive, @uses {
+  UsesDirective() { uses(this, _) }
+
+  /**
+   * Gets the qualified name of the service interface specified in this `uses` directive.
+   */
+  string getServiceInterfaceName() { uses(this, result) }
+
+  override string toString() { result = "uses " + getServiceInterfaceName() + ";" }
+}
+
+/**
+ * A `provides` directive in a module declaration.
+ */
+class ProvidesDirective extends Directive, @provides {
+  ProvidesDirective() { provides(this, _) }
+
+  /**
+   * Gets the qualified name of the service interface specified in this `provides` directive.
+   */
+  string getServiceInterfaceName() { provides(this, result) }
+
+  /**
+   * Gets the qualified name of a service implementation specified in this `provides` directive.
+   */
+  string getServiceImplementationName() { providesWith(this, result) }
+
+  override string toString() {
+    result =
+      "provides " + getServiceInterfaceName() + " with " +
+        concat(getServiceImplementationName(), ", ") + ";"
+  }
+}