Refactor

src/main/java/org/checkerframework/specimin/unsolved/MemberType.java

@@ -11,7 +11,7 @@
  * UnsolvedField} to ensure proper types when alternates are generated.
  */
 public abstract class MemberType {
-  private final List<MemberType> typeArguments;
+  private List<MemberType> typeArguments;
 
   /**
    * Creates a new MemberType with the given type arguments.
@@ -38,4 +38,13 @@ public MemberType(List<MemberType> typeArguments) {
   public List<MemberType> getTypeArguments() {
     return typeArguments;
   }
+
+  /**
+   * Sets the type arguments for this type.
+   *
+   * @param typeArguments The list of member types representing the type arguments of this type
+   */
+  public void setTypeArguments(List<MemberType> typeArguments) {
+    this.typeArguments = typeArguments;
+  }
 }

src/main/java/org/checkerframework/specimin/unsolved/UnsolvedClassOrInterfaceAlternates.java

@@ -2,6 +2,7 @@
 
 import java.util.ArrayList;
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
@@ -213,12 +214,17 @@ public void addSuperType(Set<MemberType> superTypes) {
       }
     }
 
+    Set<MemberType> sanitizedSuperTypes = new LinkedHashSet<>();
+    for (MemberType superType : superTypes) {
+      sanitizedSuperTypes.add(sanitizeMemberTypeForSuperTyping(superType));
+    }
+
     if (commonType == UnsolvedClassOrInterfaceType.CLASS) {
-      superTypeRelationships.put(superTypes, SuperTypeRelationship.EXTENDS);
+      superTypeRelationships.put(sanitizedSuperTypes, SuperTypeRelationship.EXTENDS);
     } else if (commonType == UnsolvedClassOrInterfaceType.INTERFACE) {
-      superTypeRelationships.put(superTypes, SuperTypeRelationship.IMPLEMENTS);
+      superTypeRelationships.put(sanitizedSuperTypes, SuperTypeRelationship.IMPLEMENTS);
     } else if (superTypeRelationships.get(superTypes) == null) {
-      superTypeRelationships.put(superTypes, SuperTypeRelationship.UNKNOWN);
+      superTypeRelationships.put(sanitizedSuperTypes, SuperTypeRelationship.UNKNOWN);
     }
   }
 
@@ -242,7 +248,8 @@ public void forceSuperClass(MemberType superClass) {
       setType(UnsolvedClassOrInterfaceType.CLASS);
     }
 
-    superTypeRelationships.put(Set.of(superClass), SuperTypeRelationship.EXTENDS);
+    superTypeRelationships.put(
+        Set.of(sanitizeMemberTypeForSuperTyping(superClass)), SuperTypeRelationship.EXTENDS);
   }
 
   /**
@@ -273,7 +280,37 @@ public void forceSuperInterface(MemberType superInterface) {
       return;
     }
 
-    superTypeRelationships.put(Set.of(superInterface), SuperTypeRelationship.IMPLEMENTS);
+    superTypeRelationships.put(
+        Set.of(sanitizeMemberTypeForSuperTyping(superInterface)), SuperTypeRelationship.IMPLEMENTS);
+  }
+
+  /**
+   * Sanitizes a member type for supertyping such that it no longer contains any wildcards.
+   *
+   * @param memberType The member type to sanitize
+   * @return The sanitized member type
+   */
+  private MemberType sanitizeMemberTypeForSuperTyping(MemberType memberType) {
+    if (memberType.getTypeArguments().isEmpty()) {
+      return memberType;
+    }
+
+    List<MemberType> sanitized = new ArrayList<>();
+
+    // I'm pretty sure this is not right, but until we find a better way to do this,
+    // this is what we'll do
+    Iterator<String> getTypeArgs = getTypeVariables().iterator();
+    for (int i = 0; i < memberType.getTypeArguments().size(); i++) {
+      MemberType typeArg = memberType.getTypeArguments().get(i);
+      if (typeArg instanceof WildcardMemberType) {
+        String typeVar = getTypeArgs.next();
+        typeArg = new SolvedMemberType(typeVar);
+      }
+      sanitized.add(sanitizeMemberTypeForSuperTyping(typeArg));
+    }
+
+    memberType.setTypeArguments(sanitized);
+    return memberType;
   }
 
   /**

src/main/java/org/checkerframework/specimin/unsolved/UnsolvedSymbolGenerator.java

@@ -303,8 +303,7 @@ private void handleClassOrInterfaceType(
       generated.setNumberOfTypeVariables(type.getTypeArguments().get().size());
 
       NodeList<Type> typeArgs = type.getTypeArguments().get();
-      List<String> typeArgsPreferred =
-          new ArrayList<>(List.of(generated.getTypeVariablesAsString().split(",\\s*", -1)));
+      List<String> typeArgsPreferred = new ArrayList<>(generated.getTypeVariables());
 
       boolean changed = false;
 
@@ -2473,7 +2472,7 @@ private void handleLHSAndRHSRelationship(
           ResolvedType bound = typeParam.asWildcard().getBoundedType();
           boolean isUpperBound = typeParam.asWildcard().isUpperBounded();
 
-          String erased = JavaParserUtil.erase(bound.describe());
+          String erased = JavaParserUtil.erase(resolved.describe());
 
           Set<MemberType> rhsTypeParameters = new LinkedHashSet<>();
           for (MemberType rhsType : rhsTypes) {
@@ -2493,7 +2492,7 @@ private void handleLHSAndRHSRelationship(
               }
             }
 
-            if (!typeArg.getFullyQualifiedNames().stream().anyMatch(erased::contains)) {
+            if (!rhsType.getFullyQualifiedNames().stream().anyMatch(erased::contains)) {
               continue;
             }
 
@@ -2544,7 +2543,7 @@ private void handleLHSAndRHSRelationship(
         boolean isUpperBound = wildcard.isUpperBounded();
 
         Set<String> erased =
-            bound.getFullyQualifiedNames().stream()
+            lhsType.getFullyQualifiedNames().stream()
                 .map(JavaParserUtil::erase)
                 .collect(Collectors.toSet());
 
@@ -2566,7 +2565,7 @@ private void handleLHSAndRHSRelationship(
             }
           }
 
-          if (!typeArg.getFullyQualifiedNames().stream().anyMatch(erased::contains)) {
+          if (!rhsType.getFullyQualifiedNames().stream().anyMatch(erased::contains)) {
             continue;
           }
 

src/test/resources/navigablesetfieldexample/expected/com/example/Set.java

@@ -1,3 +1,3 @@
 package com.example;
-public interface Set<E> extends com.example.Collection<E> {
+public interface Set<T> extends com.example.Collection<T> {
 }

src/test/resources/typeargumentsuperrelationship/expected/com/example/BadFoo.java

@@ -0,0 +1,7 @@
+package com.example;
+public class BadFoo<T> {
+
+    public BadFoo() {
+        throw new java.lang.Error();
+    }
+}

src/test/resources/typeargumentsuperrelationship/expected/com/example/Bar3.java

@@ -0,0 +1,3 @@
+package com.example;
+public class Bar3 {
+}

src/test/resources/typeargumentsuperrelationship/expected/com/example/Baz3.java

@@ -0,0 +1,3 @@
+package com.example;
+public class Baz3 extends com.example.Bar3  {
+}

src/test/resources/typeargumentsuperrelationship/expected/com/example/Foo.java

@@ -1,5 +1,5 @@
 package com.example;
-public class Foo<T> {
+public class Foo<T> extends com.example.BadFoo<T>  {
 
     public Foo() {
         throw new java.lang.Error();

src/test/resources/typeargumentsuperrelationship/expected/com/example/Simple.java

@@ -4,7 +4,9 @@ public class Simple {
 
   void bar() {
     Foo<? extends Bar> foo = new Foo<Baz>();
-    Foo2<? extends Bar2> foo2 = new Foo2<Baz2>();
+    Foo<? extends Bar2> foo2 = new Foo<Baz2>();
+    BadFoo<? extends Bar3> badFoo = new BadFoo<Baz3>();
     foo = foo2;
+    badFoo = foo2;
   }
 }

src/test/resources/typeargumentsuperrelationship/input/com/example/Simple.java

@@ -3,9 +3,13 @@
 public class Simple {
     void bar() {
         Foo<? extends Bar> foo = new Foo<Baz>();
-        Foo2<? extends Bar2> foo2 = new Foo2<Baz2>();
+        Foo<? extends Bar2> foo2 = new Foo<Baz2>();
 
-        // Foo2 should extend Foo, and Bar2 should extend Bar
+        BadFoo<? extends Bar3> badFoo = new BadFoo<Baz3>(); 
+
+        // Bar2 should extend Bar
         foo = foo2;
+        // Foo should extend BadFoo, but Bar3 should have no super/subtypes
+        badFoo = foo2;
     }
 }