Adds vm/AccessFlags.java. Adds bridge and origin elements to Domain. Fixes concurrency bug. (#19)

Signed-off-by: Laird Nelson <[email protected]>

Author: ljnelson

README.md

@@ -31,7 +31,7 @@ as a Maven dependency:
     Always check https://search.maven.org/artifact/org.microbean/microbean-construct
     for up-to-date available versions.
   -->
-  <version>0.0.8</version>
+  <version>0.0.10</version>
 </dependency>
 ```
 

src/main/java/org/microbean/construct/DefaultDomain.java

@@ -40,6 +40,7 @@
 import javax.lang.model.element.TypeElement;
 
 import javax.lang.model.util.Elements;
+import javax.lang.model.util.Elements.Origin;
 import javax.lang.model.util.Types;
 
 import javax.lang.model.type.DeclaredType;
@@ -203,6 +204,14 @@ public StringName binaryName(TypeElement e) {
     }
   }
 
+  @Override // Domain
+  public boolean bridge(ExecutableElement e) {
+    e = unwrap(e);
+    try (var lock = lock()) {
+      return this.elements().isBridge(e);
+    }
+  }
+
   @Override // Domain
   public UniversalType capture(TypeMirror t) {
     t = unwrap(t);
@@ -368,6 +377,14 @@ public UniversalType nullType() {
     return UniversalType.of(this.types().getNullType(), this);
   }
 
+  @Override // Domain
+  public Origin origin(Element e) {
+    e = unwrap(e);
+    try (var lock = lock()) {
+      return this.elements().getOrigin(e);
+    }
+  }
+
   // (Canonical.)
   @Override // Domain
   public UniversalElement packageElement(final CharSequence canonicalName) {

src/main/java/org/microbean/construct/Domain.java

@@ -40,6 +40,9 @@
 import javax.lang.model.type.TypeVariable;
 import javax.lang.model.type.WildcardType;
 
+import javax.lang.model.util.Elements;
+import javax.lang.model.util.Elements.Origin;
+
 import org.microbean.construct.element.StringName;
 import org.microbean.construct.element.UniversalElement;
 
@@ -150,13 +153,34 @@ public interface Domain {
    *
    * @return a non-{@code null} {@link Name}
    *
+   * @exception NullPointerException if {@code e} is {@code null}
+   *
    * @see javax.lang.model.util.Elements#getBinaryName(TypeElement)
    *
    * @spec https://docs.oracle.com/javase/specs/jls/se21/html/jls-13.html#jls-13.1 Java Language Specification, section
    * 13.1
    */
   public Name binaryName(final TypeElement e);
 
+  /**
+   * Returns {@code true} if and only if the supplied {@link ExecutableElement} represents a <dfn>bridge method</dfn>.
+   *
+   * @param e an {@link ExecutableElement}; must not be {@code null}
+   *
+   * @return {@code true} if and only if the supplied {@link ExecutableElement} represents a bridge method
+   *
+   * @exception NullPointerException if {@code e} is {@code null}
+   *
+   * @see javax.lang.model.util.Elements#isBridge(ExecutableElement)
+   *
+   * @spec https://docs.oracle.com/javase/specs/jls/se23/html/jls-8.html#jls-8.4.8.3 Java Language Specification,
+   * section 8.4.8.3
+   *
+   * @spec https://docs.oracle.com/javase/specs/jls/se23/html/jls-15.html#jls-15.12.4.5 Java Language Specification,
+   * section 15.12.4.5
+   */
+  public boolean bridge(final ExecutableElement e);
+
   /**
    * Applies <a href="https://docs.oracle.com/javase/specs/jls/se23/html/jls-5.html#jls-5.1.10"><dfn>capture
    * conversion</dfn></a> to the supplied {@link TypeMirror}, which is normally a {@linkplain TypeKind#WILDCARD wildcard
@@ -687,6 +711,17 @@ public default TypeElement javaLangObject() {
    */
   public NullType nullType();
 
+  /**
+   * Returns the {@linkplain Origin origin} of the supplied {@link Element}.
+   *
+   * @param e a non-{@code null} {@link Element}
+   *
+   * @return a non-{@code null} {@link Origin}
+   *
+   * @see Elements#getOrigin(Element)
+   */
+  public Origin origin(final Element e);
+
   /**
    * Returns a {@link PackageElement} representing the package bearing the supplied {@code canonicalName}, <strong>or
    * {@code null} if there is no such {@link PackageElement}</strong>.

src/main/java/org/microbean/construct/UniversalConstruct.java

@@ -95,7 +95,7 @@ protected UniversalConstruct(final T delegate, final Domain domain) {
     final T unwrappedDelegate = unwrap(Objects.requireNonNull(delegate, "delegate"));
     final Runnable symbolCompleter = switch (unwrappedDelegate) {
     case null -> throw new IllegalArgumentException("delegate: " + delegate);
-    case Element e -> e::getKind;
+    case Element e -> e::getModifiers;
     case TypeMirror t -> t::getKind;
     default -> UniversalConstruct::doNothing;
     };

src/main/java/org/microbean/construct/element/UniversalElement.java

@@ -20,6 +20,8 @@
 import java.util.Optional;
 import java.util.Set;
 
+import java.util.function.Supplier;
+
 import javax.lang.model.element.Element;
 import javax.lang.model.element.ElementKind;
 import javax.lang.model.element.ElementVisitor;
@@ -63,6 +65,9 @@ public final class UniversalElement
              TypeParameterElement,
              VariableElement {
 
+  // volatile not needed
+  private Supplier<? extends List<? extends UniversalElement>> enclosedElementsSupplier;
+
   /**
    * Creates a new {@link UniversalElement}.
    *
@@ -75,8 +80,17 @@ public final class UniversalElement
    *
    * @see #delegate()
    */
+  @SuppressWarnings("try")
   public UniversalElement(final Element delegate, final Domain domain) {
     super(delegate, domain);
+    this.enclosedElementsSupplier = () -> {
+      final List<? extends UniversalElement> ees;
+      try (var lock = domain.lock()) {
+        ees = this.wrap(this.delegate().getEnclosedElements());
+        this.enclosedElementsSupplier = () -> ees;
+      }
+      return ees;
+    };
   }
 
   @Override // Element
@@ -190,9 +204,23 @@ public final List<? extends UniversalDirective> getDirectives() {
     };
   }
 
+  /*
+    java.lang.AssertionError: Filling jrt:/java.base/java/lang/String$CaseInsensitiveComparator.class during DirectoryFileObject[/modules/java.base:java/lang/Integer$IntegerCache.class]
+    at jdk.compiler/com.sun.tools.javac.util.Assert.error(Assert.java:162)
+    at jdk.compiler/com.sun.tools.javac.code.ClassFinder.fillIn(ClassFinder.java:366)
+    at jdk.compiler/com.sun.tools.javac.code.ClassFinder.complete(ClassFinder.java:302)
+    at jdk.compiler/com.sun.tools.javac.code.Symbol.complete(Symbol.java:687)
+    at jdk.compiler/com.sun.tools.javac.code.Symbol$ClassSymbol.complete(Symbol.java:1455)
+    at jdk.compiler/com.sun.tools.javac.code.Symbol.apiComplete(Symbol.java:693)
+    at jdk.compiler/com.sun.tools.javac.code.Symbol$TypeSymbol.getEnclosedElements(Symbol.java:864)
+    at jdk.compiler/com.sun.tools.javac.code.Symbol$ClassSymbol.getEnclosedElements(Symbol.java:1420)
+    at jdk.compiler/com.sun.tools.javac.code.Symbol$ClassSymbol.getEnclosedElements(Symbol.java:1264)
+    at [email protected]/org.microbean.construct.element.UniversalElement.getEnclosedElements(UniversalElement.java:195)
+  */
+  // See https://github.com/microbean/microbean-construct/issues/18
   @Override // Element
   public final List<? extends UniversalElement> getEnclosedElements() {
-    return this.wrap(this.delegate().getEnclosedElements());
+    return this.enclosedElementsSupplier.get();
   }
 
   @Override // Element

src/main/java/org/microbean/construct/vm/AccessFlags.java

@@ -0,0 +1,162 @@
+/* -*- mode: Java; c-basic-offset: 2; indent-tabs-mode: nil; coding: utf-8-unix -*-
+ *
+ * Copyright © 2025 microBean™.
+ *
+ * Licensed 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 org.microbean.construct.vm;
+
+// Even though this is in the java.lang.reflect package no reflection takes place; it's just an enum
+import java.lang.reflect.AccessFlag;
+
+import javax.lang.model.element.Element;
+import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Modifier;
+import javax.lang.model.element.ModuleElement;
+
+import javax.lang.model.util.Elements.Origin;
+
+import org.microbean.construct.Domain;
+
+/**
+ * A utility class for working with access flags.
+ *
+ * @author <a href="https://about.me/lairdnelson" target="_top">Laird Nelson</a>
+ *
+ * @spec https://docs.oracle.com/javase/specs/jvms/se23/html/jvms-4.html#jvms-4.5-200-A.1 Java Virtual Machine
+ * Specification, section 4.5
+ *
+ * @spec https://docs.oracle.com/javase/specs/jvms/se23/html/jvms-4.html#jvms-4.6-200-A.1 Java Virtual Machine
+ * Specification, section 4.6
+ *
+ * @spec https://docs.oracle.com/javase/specs/jvms/se23/html/jvms-4.html#jvms-4.7 Java Virtual Machine Specification,
+ * section 4.7
+ */
+public final class AccessFlags {
+
+  // Flags pulled from the ASM library (https://gitlab.ow2.org/asm/asm/-/blob/master/asm/src/main/java/org/objectweb/asm/Opcodes.java):
+
+  private static final int ASM_RECORD =       1 << 16;  // 0x10000 // class // (see for example https://github.com/raphw/byte-buddy/blob/byte-buddy-1.14.5/byte-buddy-dep/src/main/java/net/bytebuddy/pool/TypePool.java#L2949)
+
+  private AccessFlags() {
+    super();
+  }
+
+  /**
+   * Returns the <dfn>access flags</dfn> for the supplied {@link Element}, which is presumed to have come from the
+   * supplied {@link Domain}.
+   *
+   * @param e an {@link Element}; must not be {@code null}
+   *
+   * @param domain a {@link Domain}; must not be {@code null}
+   *
+   * @return the access flags for the supplied {@link Element}
+   *
+   * @exception NullPointerException if either argument is {@code null}
+   *
+   * @spec https://docs.oracle.com/javase/specs/jvms/se23/html/jvms-4.html#jvms-4.5-200-A.1 Java Virtual Machine
+   * Specification, section 4.5
+   *
+   * @spec https://docs.oracle.com/javase/specs/jvms/se23/html/jvms-4.html#jvms-4.6-200-A.1 Java Virtual Machine
+   * Specification, section 4.6
+   *
+   * @spec https://docs.oracle.com/javase/specs/jvms/se23/html/jvms-4.html#jvms-4.7 Java Virtual Machine Specification,
+   * section 4.7
+   */
+  @SuppressWarnings("try")
+  public static final int accessFlags(final Element e, final Domain domain) {
+    int accessFlags = 0;
+    ElementKind k;
+    try (var lock = domain.lock()) {
+      for (final Modifier m : e.getModifiers()) { // not sure this actually causes symbol completion; could be hoisted out of lock
+        accessFlags |= accessFlagMask(m);
+      }
+      k = e.getKind();
+      switch (k) {
+      case METHOD:
+        // Handle just bridge and varargs here; other stuff will happen later
+        final ExecutableElement ee = (ExecutableElement)e;
+        if (domain.bridge(ee)) {
+          accessFlags |= AccessFlag.BRIDGE.mask();
+        }
+        if (ee.isVarArgs()) {
+          accessFlags |= AccessFlag.VARARGS.mask();
+        }
+        break;
+      case MODULE:
+        // Handle just openness here; other stuff will happen later
+        if (((ModuleElement)e).isOpen()) {
+          accessFlags |= AccessFlag.OPEN.mask();
+        }
+        break;
+      }
+      accessFlags |= accessFlagMask(domain.origin(e));
+    }
+    accessFlags |= accessFlagMask(k);
+    return accessFlags;
+  }
+
+  private static final int accessFlagMask(final Modifier m) {
+    return switch (m) {
+    case null -> throw new NullPointerException("m");
+    case ABSTRACT -> AccessFlag.ABSTRACT.mask();
+    case FINAL -> AccessFlag.FINAL.mask();
+    case NATIVE -> AccessFlag.NATIVE.mask();
+    case PRIVATE -> AccessFlag.PRIVATE.mask();
+    case PROTECTED -> AccessFlag.PROTECTED.mask();
+    case PUBLIC -> AccessFlag.PUBLIC.mask();
+    case STATIC -> AccessFlag.STATIC.mask();
+    case STRICTFP -> AccessFlag.STRICT.mask();
+    case SYNCHRONIZED -> AccessFlag.SYNCHRONIZED.mask();
+    case TRANSIENT -> AccessFlag.TRANSIENT.mask();
+    case VOLATILE -> AccessFlag.VOLATILE.mask();
+    case DEFAULT, NON_SEALED, SEALED -> 0; // pass through
+    };
+  }
+
+  private static final int accessFlagMask(final ElementKind k) {
+    return switch (k) {
+    case null -> throw new NullPointerException("k");
+    case ANNOTATION_TYPE -> AccessFlag.ANNOTATION.mask() | AccessFlag.INTERFACE.mask(); // see https://docs.oracle.com/javase/specs/jvms/se23/html/jvms-4.html#jvms-4.1-200-E.1
+    case ENUM -> AccessFlag.ENUM.mask();
+    case ENUM_CONSTANT -> AccessFlag.ENUM.mask(); // perhaps odd but see https://docs.oracle.com/javase/specs/jvms/se23/html/jvms-4.html#jvms-4.5-200-A.1
+    case INTERFACE -> AccessFlag.INTERFACE.mask(); // AccessFlag.ABSTRACT.mask() needs to be in play too, but that's covered in accessFlagMask(Modifier)
+    case MODULE -> AccessFlag.MODULE.mask();
+    case RECORD -> ASM_RECORD; // Some bytecode libraries use this to divine "recordness"; AccessFlag doesn't expose it and the JVM spec doesn't define it
+    case
+      BINDING_VARIABLE,
+      CLASS,
+      CONSTRUCTOR,
+      EXCEPTION_PARAMETER,
+      FIELD,
+      INSTANCE_INIT,
+      LOCAL_VARIABLE,
+      METHOD,
+      OTHER,
+      PACKAGE,
+      PARAMETER,
+      RECORD_COMPONENT,
+      RESOURCE_VARIABLE,
+      STATIC_INIT,
+      TYPE_PARAMETER -> 0; // pass through
+    };
+  }
+
+  private static final int accessFlagMask(final Origin o) {
+    return switch (o) {
+    case null -> throw new NullPointerException("o");
+    case EXPLICIT -> 0;
+    case MANDATED -> AccessFlag.MANDATED.mask();
+    case SYNTHETIC -> AccessFlag.SYNTHETIC.mask();
+    };
+  }
+
+}