Consider visibility when resolving wildcard imports

As reported in bazelbuild/bazel#21509

PiperOrigin-RevId: 611478456

java/com/google/turbine/binder/Resolve.java

@@ -101,6 +101,12 @@ public static ResolveFunction resolveFunction(
           return null;
         }
       }
+
+      @Override
+      public boolean visible(ClassSymbol sym) {
+        String packageName = origin != null ? origin.packageName() : null;
+        return importVisible(env, sym, packageName);
+      }
     };
   }
 
@@ -131,18 +137,23 @@ public CanonicalResolver(String packagename, CompoundEnv<ClassSymbol, BoundClass
 
     @Override
     public boolean visible(ClassSymbol sym) {
-      TurbineVisibility visibility = TurbineVisibility.fromAccess(env.getNonNull(sym).access());
-      switch (visibility) {
-        case PUBLIC:
-          return true;
-        case PROTECTED:
-        case PACKAGE:
-          return Objects.equals(sym.packageName(), packagename);
-        case PRIVATE:
-          return false;
-      }
-      throw new AssertionError(visibility);
+      return importVisible(env, sym, packagename);
+    }
+  }
+
+  private static boolean importVisible(
+      Env<ClassSymbol, ? extends BoundClass> env, ClassSymbol sym, @Nullable String packagename) {
+    TurbineVisibility visibility = TurbineVisibility.fromAccess(env.getNonNull(sym).access());
+    switch (visibility) {
+      case PUBLIC:
+        return true;
+      case PROTECTED:
+      case PACKAGE:
+        return Objects.equals(sym.packageName(), packagename);
+      case PRIVATE:
+        return false;
     }
+    throw new AssertionError(visibility);
   }
 
   /**

java/com/google/turbine/binder/lookup/ImportScope.java

@@ -31,9 +31,10 @@ public interface ImportScope {
    * A function that performs non-canonical resolution, see {@link
    * com.google.turbine.binder.Resolve#resolve}.
    */
-  @FunctionalInterface
   interface ResolveFunction {
     @Nullable ClassSymbol resolveOne(ClassSymbol base, Tree.Ident name);
+
+    boolean visible(ClassSymbol sym);
   }
 
   /** See {@link Scope#lookup(LookupKey)}. */

java/com/google/turbine/binder/lookup/WildImportIndex.java

@@ -29,8 +29,6 @@
  *
  * <p>Resolution is lazy, imports are not evaluated until the first request for a matching simple
  * name.
- *
- * <p>Static on-demand imports of types are not supported.
  */
 public class WildImportIndex implements ImportScope {
 
@@ -160,9 +158,14 @@ public static WildImportIndex create(
         continue;
       }
       LookupResult result = scope.lookup(lookup, resolve);
-      if (result != null) {
-        return result;
+      if (result == null) {
+        continue;
+      }
+      ClassSymbol sym = (ClassSymbol) result.sym();
+      if (!resolve.visible(sym)) {
+        continue;
       }
+      return result;
     }
     return null;
   }

javatests/com/google/turbine/lower/LowerIntegrationTest.java

@@ -301,6 +301,8 @@ public static Iterable<Object[]> parameters() {
       "simplemethod.test",
       "source_anno_retention.test",
       "source_bootclasspath_order.test",
+      "star_import_visibility.test",
+      "star_import_visibility_nested.test",
       "static_final_boxed.test",
       "static_member_type_import.test",
       "static_member_type_import_recursive.test",

javatests/com/google/turbine/lower/testdata/star_import_visibility.test

@@ -0,0 +1,21 @@
+=== a/Lib.java ===
+package a;
+class Lib {
+}
+=== b/Lib.java ===
+package b;
+public class Lib {
+}
+=== T.java ===
+import a.*; // a.Lib is not visible, b.Lib should be resolved
+import b.*;
+class T {
+  Lib x;
+}
+=== a/SamePackage.java ===
+package a;
+import a.*; // a.Lib is visible
+import b.*;
+class SamePackage {
+  Lib x;
+}

javatests/com/google/turbine/lower/testdata/star_import_visibility_nested.test

@@ -0,0 +1,22 @@
+=== a/Lib.java ===
+package a;
+public class Lib {
+  protected static class Inner {}
+}
+=== b/Lib.java ===
+package b;
+public class Lib {
+  public static class Inner {}
+}
+=== T.java ===
+import a.Lib.*;
+import b.Lib.*;
+class T {
+  Inner x;
+}
+=== S.java ===
+import static a.Lib.*;
+import static b.Lib.*;
+class S {
+  Inner x;
+}