Fix requalifying type variable uses during viewpoint adaptation

framework/src/main/java/org/checkerframework/framework/type/AbstractViewpointAdapter.java

@@ -273,6 +273,8 @@ protected AnnotatedTypeMirror combineAnnotationWithType(
             if (!isTypeVarExtends) {
                 isTypeVarExtends = true;
                 AnnotatedTypeVariable atv = (AnnotatedTypeVariable) declared.shallowCopy();
+                AnnotationMirror primaryAnnotation =
+                        atv.getAnnotationInHierarchy(receiverAnnotation);
                 IdentityHashMap<AnnotatedTypeMirror, AnnotatedTypeMirror> mappings =
                         new IdentityHashMap<>();
 
@@ -284,9 +286,18 @@ protected AnnotatedTypeMirror combineAnnotationWithType(
                 AnnotatedTypeMirror resLower =
                         combineAnnotationWithType(receiverAnnotation, atv.getLowerBound());
                 mappings.put(atv.getLowerBound(), resLower);
-
+                // The values of the mappings are the viewpoint adapted lower and upper bounds,
+                // and we wish to replace the old bounds of atv with the new mappings.
+                // However, we need to first remove the primary annotations of atv, otherwise
+                // in later replacement, the primary annotations would override our computed
+                // new mappings (see method fixupBoundAnnotations).
+                atv.removeAnnotationInHierarchy(receiverAnnotation);
                 AnnotatedTypeMirror result =
                         AnnotatedTypeCopierWithReplacement.replace(atv, mappings);
+                if (primaryAnnotation != null) {
+                    result.replaceAnnotation(
+                            combineAnnotationWithAnnotation(receiverAnnotation, primaryAnnotation));
+                }
 
                 isTypeVarExtends = false;
                 return result;
@@ -404,7 +415,12 @@ private AnnotatedTypeMirror substituteTVars(AnnotatedTypeMirror lhs, AnnotatedTy
 
             // Base case where actual type argument is extracted
             if (lhs.getKind() == TypeKind.DECLARED) {
+                // Replace type variable with its actual type argument
                 rhs = getTypeVariableSubstitution((AnnotatedDeclaredType) lhs, atv);
+                // If the type variable use has a primary annotation, apply it to the substitute.
+                if (!atv.getAnnotationsField().isEmpty()) {
+                    rhs.replaceAnnotations(atv.getAnnotations());
+                }
             }
         } else if (rhs.getKind() == TypeKind.DECLARED) {
             AnnotatedDeclaredType adt = (AnnotatedDeclaredType) rhs.shallowCopy();

framework/tests/viewpointtest/AnnoOnTypeVariableUse.java

@@ -0,0 +1,31 @@
+import viewpointtest.quals.*;
+
+@SuppressWarnings("cast.unsafe.constructor.invocation")
+class AnnoOnTypeVariableUse<E> {
+    @ReceiverDependentQual E rdq;
+    @A E a;
+    @B E b;
+    E c;
+
+    void test() {
+        AnnoOnTypeVariableUse<@B Element> d = new @A AnnoOnTypeVariableUse<>();
+        // d.element = @A |> @RDQ = @A
+        d.rdq = new @A Element();
+        // :: error: (assignment.type.incompatible)
+        d.rdq = new @B Element();
+        // d.a = @A |> @A = @A
+        d.a = new @A Element();
+        // :: error: (assignment.type.incompatible)
+        d.a = new @B Element();
+        // d.b = @A |> @B = @B
+        d.b = new @B Element();
+        // :: error: (assignment.type.incompatible)
+        d.b = new @A Element();
+        // :: error: (assignment.type.incompatible)
+        d.c = new @A Element();
+        // d.c = @B type argument subsitution with unannotated field
+        d.c = new @B Element();
+    }
+
+    class Element {}
+}