Use the new TypeUseLocation default locations

.github/workflows/build.yml

@@ -30,11 +30,12 @@ jobs:
         run: ./gradlew build conformanceTests demoTest --include-build ../jspecify
         env:
           SHALLOW: 1
-      - name: Check out jspecify/samples-google-prototype
+          JSPECIFY_CONFORMANCE_TEST_MODE: details
+      - name: Check out jspecify/samples-google-prototype-eisop
         if: always()
         run: |
-          git fetch --depth=1 origin samples-google-prototype
-          git checkout samples-google-prototype
+          git fetch --depth=1 origin samples-google-prototype-eisop
+          git checkout samples-google-prototype-eisop
         working-directory: jspecify
       - name: Run Samples Tests
         if: always()

initialize-project

@@ -11,7 +11,7 @@
 # Set SHALLOW=1 to clone sibling projects at depth 1.
 #
 # This script automatically tries to download your fork of
-# jspecify/checker-framework, jspecify/jspecify, or jspecify/jdk, if they exist.
+# eisop/checker-framework, jspecify/jspecify, or jspecify/jdk, if they exist.
 # It uses the URL of the origin remote (the default remote created when cloning
 # a repo) to determine that.
 #
@@ -55,12 +55,19 @@ git_clone() {
 
   local forking_org
   forking_org="$(forking_org)"
-  if [[ -n "${forking_org}" ]]; then
+  if [[ -n "${forking_org}" ]] \
+    && [[ "${forking_org}" != "https://github.com/jspecify" ]] \
+    && [[ "${forking_org}" != "[email protected]:jspecify" ]] ; then
     if run "${git[@]}" "${forking_org}/${repo}.git" "../${repo}"; then
       return
     fi
   fi
-  run "${git[@]}" "https://github.com/jspecify/${repo}.git" "../${repo}"
+  if [[ "${repo}" == "checker-framework" ]]; then
+    forking_org=https://github.com/eisop
+  else
+    forking_org=https://github.com/jspecify
+  fi
+  run "${git[@]}" "${forking_org}/${repo}.git" "../${repo}"
 }
 
 git_clone jdk --depth 1 --single-branch

settings.gradle

@@ -15,13 +15,13 @@ includeBuild("../checker-framework")
 dependencyResolutionManagement {
     versionCatalogs {
         libs {
-            version("checkerFramework", "3.21.5-SNAPSHOT")
+            version("checkerFramework", "3.42.0-eisop3-SNAPSHOT")
 
-            library("checkerFramework-checker", "org.checkerframework", "checker").versionRef("checkerFramework")
-            library("checkerFramework-checker-qual", "org.checkerframework", "checker-qual").versionRef("checkerFramework")
-            library("checkerFramework-framework", "org.checkerframework", "framework").versionRef("checkerFramework")
-            library("checkerFramework-framework-test", "org.checkerframework", "framework-test").versionRef("checkerFramework")
-            library("checkerFramework-javacutil", "org.checkerframework", "javacutil").versionRef("checkerFramework")
+            library("checkerFramework-checker", "io.github.eisop", "checker").versionRef("checkerFramework")
+            library("checkerFramework-checker-qual", "io.github.eisop", "checker-qual").versionRef("checkerFramework")
+            library("checkerFramework-framework", "io.github.eisop", "framework").versionRef("checkerFramework")
+            library("checkerFramework-framework-test", "io.github.eisop", "framework-test").versionRef("checkerFramework")
+            library("checkerFramework-javacutil", "io.github.eisop", "javacutil").versionRef("checkerFramework")
             library("errorProne-core", "com.google.errorprone:error_prone_core:2.18.0")
             library("errorProne-javac", "com.google.errorprone:javac:9+181-r4173-1")
             library("guava", "com.google.guava:guava:31.1-jre")

src/main/java/com/google/jspecify/nullness/ConformanceTypeInformationPresenter.java

@@ -0,0 +1,108 @@
+// Copyright 2024 The JSpecify Authors
+//
+// 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 com.google.jspecify.nullness;
+
+import com.sun.source.tree.AssignmentTree;
+import com.sun.source.tree.ClassTree;
+import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.MethodInvocationTree;
+import com.sun.source.tree.Tree;
+import java.util.List;
+import javax.lang.model.element.ExecutableElement;
+import org.checkerframework.framework.type.AnnotatedTypeFactory;
+import org.checkerframework.framework.type.AnnotatedTypeFormatter;
+import org.checkerframework.framework.type.AnnotatedTypeMirror;
+import org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedExecutableType;
+import org.checkerframework.framework.util.visualize.AbstractTypeInformationPresenter;
+import org.checkerframework.framework.util.visualize.TypeOccurrenceKind;
+import org.checkerframework.javacutil.TreeUtils;
+
+/**
+ * Output "sinkType" and "sourceType" diagnostic warning messages so the conformance tests can look
+ * for (a subset of) them.
+ */
+public final class ConformanceTypeInformationPresenter extends AbstractTypeInformationPresenter {
+
+  /**
+   * Constructs a presenter for the given factory.
+   *
+   * @param atypeFactory the AnnotatedTypeFactory for the current analysis
+   */
+  public ConformanceTypeInformationPresenter(AnnotatedTypeFactory atypeFactory) {
+    super(atypeFactory);
+  }
+
+  @Override
+  protected AnnotatedTypeFormatter createTypeFormatter() {
+    // Use the same type formatter as normal error messages. Look into whether a different format
+    // would be better here.
+    return atypeFactory.getAnnotatedTypeFormatter();
+  }
+
+  @Override
+  protected TypeInformationReporter createTypeInformationReporter(ClassTree tree) {
+    return new ConformanceTypeInformationReporter(tree);
+  }
+
+  class ConformanceTypeInformationReporter extends TypeInformationReporter {
+    ConformanceTypeInformationReporter(ClassTree tree) {
+      super(tree);
+    }
+
+    @Override
+    protected void reportTreeType(
+        Tree tree, AnnotatedTypeMirror type, TypeOccurrenceKind occurrenceKind) {
+      switch (tree.getKind()) {
+        case ASSIGNMENT:
+          AssignmentTree asgn = (AssignmentTree) tree;
+          AnnotatedTypeMirror varType =
+              genFactory != null
+                  ? genFactory.getAnnotatedTypeLhs(asgn.getVariable())
+                  : atypeFactory.getAnnotatedType(asgn.getVariable());
+          checker.reportWarning(
+              asgn.getVariable(),
+              "sinkType",
+              typeFormatter.format(varType),
+              asgn.getVariable().toString());
+          break;
+        case RETURN:
+          checker.reportWarning(tree, "sinkType", typeFormatter.format(type), "return");
+          break;
+        case METHOD_INVOCATION:
+          ExecutableElement calledElem = TreeUtils.elementFromUse((MethodInvocationTree) tree);
+          String methodName = calledElem.getSimpleName().toString();
+          AnnotatedExecutableType calledType = (AnnotatedExecutableType) type;
+          List<? extends AnnotatedTypeMirror> params = calledType.getParameterTypes();
+          MethodInvocationTree mit = (MethodInvocationTree) tree;
+          List<? extends ExpressionTree> args = mit.getArguments();
+          assert params.size() == args.size();
+
+          for (int i = 0; i < params.size(); ++i) {
+            String paramName = calledElem.getParameters().get(i).getSimpleName().toString();
+            String paramLocation = String.format("%s#%s", methodName, paramName);
+            checker.reportWarning(
+                tree, "sinkType", typeFormatter.format(params.get(i)), paramLocation);
+          }
+          break;
+        default:
+          // Nothing special for other trees.
+      }
+
+      if (TreeUtils.isExpressionTree(tree)) {
+        checker.reportWarning(tree, "sourceType", typeFormatter.format(type), tree.toString());
+      }
+    }
+  }
+}

src/main/java/com/google/jspecify/nullness/NullSpecAnalysis.java

@@ -14,12 +14,11 @@
 
 package com.google.jspecify.nullness;
 
-import java.util.Set;
-import javax.lang.model.element.AnnotationMirror;
 import javax.lang.model.type.TypeMirror;
 import org.checkerframework.common.basetype.BaseTypeChecker;
 import org.checkerframework.framework.flow.CFAbstractAnalysis;
 import org.checkerframework.framework.flow.CFValue;
+import org.checkerframework.javacutil.AnnotationMirrorSet;
 
 final class NullSpecAnalysis extends CFAbstractAnalysis<CFValue, NullSpecStore, NullSpecTransfer> {
   NullSpecAnalysis(BaseTypeChecker checker, NullSpecAnnotatedTypeFactory factory) {
@@ -37,7 +36,7 @@ public NullSpecStore createCopiedStore(NullSpecStore other) {
   }
 
   @Override
-  public CFValue createAbstractValue(Set<AnnotationMirror> annotations, TypeMirror underlyingType) {
+  public CFValue createAbstractValue(AnnotationMirrorSet annotations, TypeMirror underlyingType) {
     return defaultCreateAbstractValue(this, annotations, underlyingType);
   }
 }