1

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/ClasspathRootsResolver.kt

@@ -22,6 +22,7 @@ import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiJavaModule
 import com.intellij.psi.PsiManager
 import com.intellij.psi.impl.light.LightJavaModule
+import com.intellij.testFramework.LightVirtualFile
 import org.jetbrains.kotlin.cli.common.config.ContentRoot
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
@@ -37,6 +38,7 @@ import org.jetbrains.kotlin.cli.jvm.modules.CliJavaModuleFinder
 import org.jetbrains.kotlin.cli.jvm.modules.JavaModuleGraph
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.isValidJavaFqName
+import org.jetbrains.kotlin.resolve.jvm.KotlinCliJavaFileManager
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModule
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleInfo
 import org.jetbrains.kotlin.resolve.jvm.modules.KOTLIN_STDLIB_MODULE_NAME
@@ -52,7 +54,8 @@ class ClasspathRootsResolver(
     private val contentRootToVirtualFile: (JvmContentRoot) -> VirtualFile?,
     private val javaModuleFinder: CliJavaModuleFinder,
     private val requireStdlibModule: Boolean,
-    private val outputDirectory: VirtualFile?
+    private val outputDirectory: VirtualFile?,
+    private val javaFileManager: KotlinCliJavaFileManager
 ) {
     val javaModuleGraph = JavaModuleGraph(javaModuleFinder)
 
@@ -160,7 +163,7 @@ class ClasspathRootsResolver(
                 }
 
         if (moduleInfoFile != null) {
-            val moduleInfo = JavaModuleInfo.read(moduleInfoFile) ?: return null
+            val moduleInfo = JavaModuleInfo.read(moduleInfoFile, javaFileManager) ?: return null
             return JavaModule.Explicit(moduleInfo, listOf(JavaModule.Root(root, isBinary = true)), moduleInfoFile)
         }
 

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliVirtualFileFinder.kt

@@ -35,6 +35,10 @@ class CliVirtualFileFinder(
     override fun findVirtualFileWithHeader(classId: ClassId): VirtualFile? =
         findBinaryClass(classId, classId.relativeClassName.asString().replace('.', '$') + ".class")
 
+    override fun findSourceOrBinaryVirtualFile(classId: ClassId) =
+        findBinaryClass(classId, classId.relativeClassName.asString().replace('.', '$') + ".class")
+            ?: findSourceClass(classId, classId.relativeClassName.asString() + ".java")
+
     override fun findMetadata(classId: ClassId): InputStream? {
         assert(!classId.isNestedClass) { "Nested classes are not supported here: $classId" }
 
@@ -61,8 +65,11 @@ class CliVirtualFileFinder(
         return findBinaryClass(classId, BuiltInSerializerProtocol.getBuiltInsFileName(packageFqName))?.inputStream
     }
 
-    private fun findBinaryClass(classId: ClassId, fileName: String): VirtualFile? =
-        index.findClass(classId, acceptedRootTypes = JavaRoot.OnlyBinary) { dir, _ ->
+    private fun findClass(classId: ClassId, fileName: String, rootType: Set<JavaRoot.RootType>) =
+        index.findClass(classId, acceptedRootTypes = rootType) { dir, _ ->
             dir.findChild(fileName)?.takeIf(VirtualFile::isValid)
         }?.takeIf { it in scope }
+
+    private fun findBinaryClass(classId: ClassId, fileName: String) = findClass(classId, fileName, JavaRoot.OnlyBinary)
+    private fun findSourceClass(classId: ClassId, fileName: String) = findClass(classId, fileName, JavaRoot.OnlySource)
 }

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCliJavaFileManagerImpl.kt

@@ -82,7 +82,9 @@ class KotlinCliJavaFileManagerImpl(private val myPsiManager: PsiManager) : CoreJ
     private val binaryCache: MutableMap<ClassId, JavaClass?> = THashMap()
     private val signatureParsingComponent = BinaryClassSignatureParser()
 
-    fun findClass(classId: ClassId, searchScope: GlobalSearchScope): JavaClass? = findClass(JavaClassFinder.Request(classId), searchScope)
+    fun findClass(classId: ClassId, searchScope: GlobalSearchScope) = findClass(JavaClassFinder.Request(classId), searchScope)
+
+    override fun findClass(classId: ClassId): JavaClass? = findClass(JavaClassFinder.Request(classId), allScope)
 
     override fun findClass(request: JavaClassFinder.Request, searchScope: GlobalSearchScope): JavaClass? {
         val (classId, classFileContentFromRequest, outerClassFromRequest) = request
@@ -110,7 +112,7 @@ class KotlinCliJavaFileManagerImpl(private val myPsiManager: PsiManager) : CoreJ
                 val classContent = classFileContentFromRequest ?: virtualFile.contentsToByteArray()
                 if (virtualFile.nameWithoutExtension.contains("$") && isNotTopLevelClass(classContent)) return@getOrPut null
 
-                val resolver = ClassifierResolutionContext { findClass(it, allScope) }
+                val resolver = ClassifierResolutionContext { findClass(it) }
 
                 BinaryJavaClass(
                     virtualFile, classId.asSingleFqName(), resolver, signatureParsingComponent,

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt

@@ -33,13 +33,11 @@ import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.extensions.ExtensionsArea
 import com.intellij.openapi.fileTypes.PlainTextFileType
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.roots.LanguageLevelProjectExtension
 import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.util.io.FileUtilRt
 import com.intellij.openapi.util.text.StringUtil
 import com.intellij.openapi.vfs.*
 import com.intellij.openapi.vfs.impl.ZipHandler
-import com.intellij.pom.java.LanguageLevel
 import com.intellij.psi.PsiElementFinder
 import com.intellij.psi.PsiManager
 import com.intellij.psi.impl.JavaClassSupersImpl
@@ -191,11 +189,16 @@ class KotlinCoreEnvironment private constructor(
 
         sourceFiles.sortBy { it.virtualFile.path }
 
+        val javaFileManager = ServiceManager.getService(project, CoreJavaFileManager::class.java) as KotlinCliJavaFileManagerImpl
+
         val jdkHome = configuration.get(JVMConfigurationKeys.JDK_HOME)
         val jrtFileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.JRT_PROTOCOL)
-        val javaModuleFinder = CliJavaModuleFinder(jdkHome?.path?.let { path ->
-            jrtFileSystem?.findFileByPath(path + URLUtil.JAR_SEPARATOR)
-        })
+        val javaModuleFinder = CliJavaModuleFinder(
+            jdkHome?.path?.let { path ->
+                jrtFileSystem?.findFileByPath(path + URLUtil.JAR_SEPARATOR)
+            },
+            javaFileManager
+        )
 
         val outputDirectory =
             configuration.get(JVMConfigurationKeys.MODULES)?.singleOrNull()?.getOutputDirectory()
@@ -208,7 +211,8 @@ class KotlinCoreEnvironment private constructor(
             this::contentRootToVirtualFile,
             javaModuleFinder,
             !configuration.getBoolean(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE),
-            outputDirectory?.let(this::findLocalFile)
+            outputDirectory?.let(this::findLocalFile),
+            javaFileManager
         )
 
         val (initialRoots, javaModules) =
@@ -232,7 +236,7 @@ class KotlinCoreEnvironment private constructor(
             updateClasspathFromRootsIndex(this)
         }
 
-        (ServiceManager.getService(project, CoreJavaFileManager::class.java) as KotlinCliJavaFileManagerImpl).initialize(
+        javaFileManager.initialize(
             rootsIndex,
             packagePartProviders,
             SingleJavaFileRootsIndex(singleJavaFileRoots),
@@ -241,7 +245,7 @@ class KotlinCoreEnvironment private constructor(
 
         project.registerService(
             JavaModuleResolver::class.java,
-            CliJavaModuleResolver(classpathRootsResolver.javaModuleGraph, javaModules, javaModuleFinder.systemModules.toList())
+            CliJavaModuleResolver(classpathRootsResolver.javaModuleGraph, javaModules, javaModuleFinder.systemModules.toList(), project)
         )
 
         val finderFactory = CliVirtualFileFinderFactory(rootsIndex)

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt.as42

@@ -78,10 +78,7 @@ import org.jetbrains.kotlin.cli.jvm.modules.CoreJrtFileSystem
 import org.jetbrains.kotlin.codegen.extensions.ClassBuilderInterceptorExtension
 import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension
 import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
-import org.jetbrains.kotlin.config.APPEND_JAVA_SOURCE_ROOTS_HANDLER_KEY
-import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
-import org.jetbrains.kotlin.config.languageVersionSettings
+import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.extensions.*
 import org.jetbrains.kotlin.extensions.internal.CandidateInterceptor
 import org.jetbrains.kotlin.extensions.internal.TypeResolutionInterceptor
@@ -192,11 +189,16 @@ class KotlinCoreEnvironment private constructor(
 
         sourceFiles.sortBy { it.virtualFile.path }
 
+        val javaFileManager = ServiceManager.getService(project, CoreJavaFileManager::class.java) as KotlinCliJavaFileManagerImpl
+
         val jdkHome = configuration.get(JVMConfigurationKeys.JDK_HOME)
         val jrtFileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.JRT_PROTOCOL)
-        val javaModuleFinder = CliJavaModuleFinder(jdkHome?.path?.let { path ->
-            jrtFileSystem?.findFileByPath(path + URLUtil.JAR_SEPARATOR)
-        })
+        val javaModuleFinder = CliJavaModuleFinder(
+            jdkHome?.path?.let { path ->
+                jrtFileSystem?.findFileByPath(path + URLUtil.JAR_SEPARATOR)
+            },
+            javaFileManager
+        )
 
         val outputDirectory =
             configuration.get(JVMConfigurationKeys.MODULES)?.singleOrNull()?.getOutputDirectory()
@@ -209,7 +211,8 @@ class KotlinCoreEnvironment private constructor(
             this::contentRootToVirtualFile,
             javaModuleFinder,
             !configuration.getBoolean(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE),
-            outputDirectory?.let(this::findLocalFile)
+            outputDirectory?.let(this::findLocalFile),
+            javaFileManager
         )
 
         val (initialRoots, javaModules) =
@@ -233,7 +236,7 @@ class KotlinCoreEnvironment private constructor(
             updateClasspathFromRootsIndex(this)
         }
 
-        (ServiceManager.getService(project, CoreJavaFileManager::class.java) as KotlinCliJavaFileManagerImpl).initialize(
+        javaFileManager.initialize(
             rootsIndex,
             packagePartProviders,
             SingleJavaFileRootsIndex(singleJavaFileRoots),
@@ -242,7 +245,7 @@ class KotlinCoreEnvironment private constructor(
 
         project.registerService(
             JavaModuleResolver::class.java,
-            CliJavaModuleResolver(classpathRootsResolver.javaModuleGraph, javaModules, javaModuleFinder.systemModules.toList())
+            CliJavaModuleResolver(classpathRootsResolver.javaModuleGraph, javaModules, javaModuleFinder.systemModules.toList(), project)
         )
 
         val finderFactory = CliVirtualFileFinderFactory(rootsIndex)

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/config/JvmContentRoots.kt

@@ -49,6 +49,9 @@ fun CompilerConfiguration.addJvmSdkRoots(files: List<File>) {
 val CompilerConfiguration.jvmClasspathRoots: List<File>
     get() = getList(CLIConfigurationKeys.CONTENT_ROOTS).filterIsInstance<JvmClasspathRoot>().map(JvmContentRoot::file)
 
+val CompilerConfiguration.jvmModularRoots: List<File>
+    get() = getList(CLIConfigurationKeys.CONTENT_ROOTS).filterIsInstance<JvmModulePathRoot>().map(JvmContentRoot::file)
+
 @JvmOverloads
 fun CompilerConfiguration.addJavaSourceRoot(file: File, packagePrefix: String? = null) {
     add(CLIConfigurationKeys.CONTENT_ROOTS, JavaSourceRoot(file, packagePrefix))

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/index/JvmDependenciesIndex.kt

@@ -45,6 +45,7 @@ data class JavaRoot(val file: VirtualFile, val type: RootType, val prefixFqName:
 
     companion object RootTypes {
         val OnlyBinary: Set<RootType> = EnumSet.of(RootType.BINARY)
+        val OnlySource: Set<RootType> = EnumSet.of(RootType.SOURCE)
         val SourceAndBinary: Set<RootType> = EnumSet.of(RootType.BINARY, RootType.SOURCE)
     }
 }

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/modules/CliJavaModuleFinder.kt

@@ -18,11 +18,12 @@ package org.jetbrains.kotlin.cli.jvm.modules
 
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiJavaModule
+import org.jetbrains.kotlin.resolve.jvm.KotlinCliJavaFileManager
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModule
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleFinder
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleInfo
 
-class CliJavaModuleFinder(jrtFileSystemRoot: VirtualFile?) : JavaModuleFinder {
+class CliJavaModuleFinder(jrtFileSystemRoot: VirtualFile?, val javaFileManager: KotlinCliJavaFileManager) : JavaModuleFinder {
     private val modulesRoot = jrtFileSystemRoot?.findChild("modules")
     private val userModules = linkedMapOf<String, JavaModule>()
 
@@ -41,7 +42,7 @@ class CliJavaModuleFinder(jrtFileSystemRoot: VirtualFile?) : JavaModuleFinder {
 
     private fun findSystemModule(moduleRoot: VirtualFile): JavaModule.Explicit? {
         val file = moduleRoot.findChild(PsiJavaModule.MODULE_INFO_CLS_FILE) ?: return null
-        val moduleInfo = JavaModuleInfo.read(file) ?: return null
+        val moduleInfo = JavaModuleInfo.read(file, javaFileManager) ?: return null
         return JavaModule.Explicit(moduleInfo, listOf(JavaModule.Root(moduleRoot, isBinary = true)), file)
     }
 }

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/modules/CliJavaModuleResolver.kt

@@ -18,10 +18,14 @@ package org.jetbrains.kotlin.cli.jvm.modules
 
 import com.intellij.ide.highlighter.JavaClassFileType
 import com.intellij.ide.highlighter.JavaFileType
+import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.StandardFileSystems
 import com.intellij.openapi.vfs.VfsUtilCore
 import com.intellij.openapi.vfs.VirtualFile
 import org.jetbrains.kotlin.idea.KotlinFileType
+import org.jetbrains.kotlin.load.java.structure.JavaAnnotation
+import org.jetbrains.kotlin.load.kotlin.VirtualFileFinder
+import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModule
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleResolver
@@ -29,7 +33,8 @@ import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleResolver
 class CliJavaModuleResolver(
     private val moduleGraph: JavaModuleGraph,
     private val userModules: List<JavaModule>,
-    private val systemModules: List<JavaModule.Explicit>
+    private val systemModules: List<JavaModule.Explicit>,
+    private val project: Project
 ) : JavaModuleResolver {
     init {
         assert(userModules.count(JavaModule::isSourceModule) <= 1) {
@@ -37,6 +42,13 @@ class CliJavaModuleResolver(
         }
     }
 
+    private val virtualFileFinder by lazy { VirtualFileFinder.getInstance(project) }
+
+    override fun getModuleAnnotations(classId: ClassId): List<JavaAnnotation>? {
+        val virtualFile = virtualFileFinder.findSourceOrBinaryVirtualFile(classId) ?: return null
+        return (findJavaModule(virtualFile) as? JavaModule.Explicit)?.moduleInfo?.annotations
+    }
+
     private val sourceModule: JavaModule? = userModules.firstOrNull(JavaModule::isSourceModule)
 
     private fun findJavaModule(file: VirtualFile): JavaModule? {

compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt

@@ -45,6 +45,7 @@ import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.calls.tower.ImplicitsExtensionsResolutionFilter
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
 import org.jetbrains.kotlin.resolve.jvm.JvmDiagnosticComponents
+import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleResolver
 import org.jetbrains.kotlin.resolve.jvm.multiplatform.OptionalAnnotationPackageFragmentProvider
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
@@ -144,6 +145,7 @@ fun StorageComponentContainer.configureJavaSpecificComponents(
             typeEnhancementImprovementsInStrictMode = languageVersionSettings.supportsFeature(LanguageFeature.TypeEnhancementImprovementsInStrictMode)
         )
     )
+    useInstance(JavaModuleResolver.getInstance(moduleContext.project))
 
     useImpl<FilesByFacadeFqNameIndexer>()
     useImpl<JvmDiagnosticComponents>()

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/VirtualFileFinder.kt

@@ -29,6 +29,8 @@ import org.jetbrains.kotlin.utils.sure
 abstract class VirtualFileFinder : KotlinClassFinder {
     abstract fun findVirtualFileWithHeader(classId: ClassId): VirtualFile?
 
+    abstract fun findSourceOrBinaryVirtualFile(classId: ClassId): VirtualFile?
+
     override fun findKotlinClassOrContent(classId: ClassId): KotlinClassFinder.Result? {
         val file = findVirtualFileWithHeader(classId) ?: return null
         return KotlinBinaryClassCache.getKotlinBinaryClassOrClassFileContent(file)

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/modules/JavaModuleInfo.kt

@@ -19,50 +19,57 @@ package org.jetbrains.kotlin.resolve.jvm.modules
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiJavaModule
 import com.intellij.psi.PsiModifier
+import org.jetbrains.kotlin.load.java.structure.JavaAnnotation
+import org.jetbrains.kotlin.load.java.structure.impl.JavaAnnotationImpl
+import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryClassSignatureParser
+import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryJavaAnnotation
+import org.jetbrains.kotlin.load.java.structure.impl.classFiles.ClassifierResolutionContext
+import org.jetbrains.kotlin.load.java.structure.impl.convert
 import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.resolve.jvm.KotlinCliJavaFileManager
+import org.jetbrains.org.objectweb.asm.*
 import org.jetbrains.kotlin.utils.compact
-import org.jetbrains.org.objectweb.asm.ClassReader
-import org.jetbrains.org.objectweb.asm.ClassVisitor
-import org.jetbrains.org.objectweb.asm.ModuleVisitor
-import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.Opcodes.ACC_TRANSITIVE
 import java.io.IOException
 
 class JavaModuleInfo(
-        val moduleName: String,
-        val requires: List<Requires>,
-        val exports: List<Exports>
+    val moduleName: String,
+    val requires: List<Requires>,
+    val exports: List<Exports>,
+    val annotations: List<JavaAnnotation>
 ) {
     data class Requires(val moduleName: String, val isTransitive: Boolean)
 
     data class Exports(val packageFqName: FqName, val toModules: List<String>)
 
-    override fun toString(): String =
-            "Module $moduleName (${requires.size} requires, ${exports.size} exports)"
+    override fun toString() = "Module $moduleName (${requires.size} requires, ${exports.size} exports)"
 
     companion object {
-        fun create(psiJavaModule: PsiJavaModule): JavaModuleInfo {
-            return JavaModuleInfo(
-                    psiJavaModule.name,
-                    psiJavaModule.requires.mapNotNull { statement ->
-                        statement.moduleName?.let { moduleName ->
-                            JavaModuleInfo.Requires(moduleName, statement.hasModifierProperty(PsiModifier.TRANSITIVE))
-                        }
-                    },
-                    psiJavaModule.exports.mapNotNull { statement ->
-                        statement.packageName?.let { packageName ->
-                            JavaModuleInfo.Exports(FqName(packageName), statement.moduleNames)
-                        }
-                    }
-            )
-        }
-
-        fun read(file: VirtualFile): JavaModuleInfo? {
-            val contents = try { file.contentsToByteArray() } catch (e: IOException) { return null }
+        fun create(psiJavaModule: PsiJavaModule) = JavaModuleInfo(
+            psiJavaModule.name,
+            psiJavaModule.requires.mapNotNull { statement ->
+                statement.moduleName?.let { moduleName ->
+                    Requires(moduleName, statement.hasModifierProperty(PsiModifier.TRANSITIVE))
+                }
+            },
+            psiJavaModule.exports.mapNotNull { statement ->
+                statement.packageName?.let { packageName ->
+                    Exports(FqName(packageName), statement.moduleNames)
+                }
+            },
+            psiJavaModule.annotations.convert(::JavaAnnotationImpl)
+        )
 
+        fun read(file: VirtualFile, javaFileManager: KotlinCliJavaFileManager): JavaModuleInfo? {
+            val contents = try {
+                file.contentsToByteArray()
+            } catch (e: IOException) {
+                return null
+            }
             var moduleName: String? = null
             val requires = arrayListOf<Requires>()
             val exports = arrayListOf<Exports>()
+            val annotations = arrayListOf<JavaAnnotation>()
 
             try {
                 ClassReader(contents).accept(object : ClassVisitor(Opcodes.API_VERSION) {
@@ -80,6 +87,21 @@ class JavaModuleInfo(
                             }
                         }
                     }
+
+                    override fun visitAnnotation(descriptor: String?, visible: Boolean): AnnotationVisitor? {
+                        if (descriptor == null) return null
+
+                        val (annotation, visitor) = BinaryJavaAnnotation.createAnnotationAndVisitor(
+                            descriptor,
+                            ClassifierResolutionContext(javaFileManager::findClass),
+                            BinaryClassSignatureParser(),
+                            isFreshlySupportedTypeUseAnnotation = true
+                        )
+
+                        annotations.add(annotation)
+
+                        return visitor
+                    }
                 }, ClassReader.SKIP_DEBUG or ClassReader.SKIP_CODE or ClassReader.SKIP_FRAMES)
             } catch (e: Exception) {
                 throw IllegalStateException(
@@ -89,9 +111,7 @@ class JavaModuleInfo(
                 )
             }
 
-            return if (moduleName != null)
-                JavaModuleInfo(moduleName!!, requires.compact(), exports.compact())
-            else null
+            return moduleName?.let { JavaModuleInfo(it, requires.compact(), exports.compact(), annotations) }
         }
     }
 }

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/modules/JavaModuleResolver.kt

@@ -19,9 +19,10 @@ package org.jetbrains.kotlin.resolve.jvm.modules
 import com.intellij.openapi.components.ServiceManager
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VirtualFile
+import org.jetbrains.kotlin.load.java.lazy.JavaModuleAnnotationsProvider
 import org.jetbrains.kotlin.name.FqName
 
-interface JavaModuleResolver {
+interface JavaModuleResolver : JavaModuleAnnotationsProvider {
     fun checkAccessibility(fileFromOurModule: VirtualFile?, referencedFile: VirtualFile, referencedPackage: FqName?): AccessError?
 
     sealed class AccessError {
@@ -31,7 +32,6 @@ interface JavaModuleResolver {
     }
 
     companion object SERVICE {
-        fun getInstance(project: Project): JavaModuleResolver =
-                ServiceManager.getService(project, JavaModuleResolver::class.java)
+        fun getInstance(project: Project): JavaModuleResolver = ServiceManager.getService(project, JavaModuleResolver::class.java)
     }
 }

compiler/resolution.common.jvm/src/org/jetbrains/kotlin/resolve/jvm/KotlinCliJavaFileManager.kt

@@ -20,9 +20,11 @@ import com.intellij.psi.impl.file.impl.JavaFileManager
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.load.java.JavaClassFinder
 import org.jetbrains.kotlin.load.java.structure.JavaClass
+import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 
 interface KotlinCliJavaFileManager : JavaFileManager {
+    fun findClass(classId: ClassId): JavaClass?
     fun findClass(request: JavaClassFinder.Request, searchScope: GlobalSearchScope): JavaClass?
     fun knownClassNamesInPackage(packageFqName: FqName): Set<String>?
 }

compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/TestJavacVersion.kt

@@ -0,0 +1,10 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.test
+
+enum class TestJavacVersion {
+    JAVAC_1_8, JAVAC_9
+}

compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/SourceFileProvider.kt

@@ -18,9 +18,11 @@ abstract class SourceFilePreprocessor(val testServices: TestServices) {
 abstract class SourceFileProvider : TestService {
     abstract val kotlinSourceDirectory: File
     abstract val javaSourceDirectory: File
+    abstract val javaBinaryDirectory: File
 
     abstract fun getContentOfSourceFile(testFile: TestFile): String
     abstract fun getRealFileForSourceFile(testFile: TestFile): File
+    abstract fun getRealFileForBinaryFile(testFile: TestFile): File
 }
 
 val TestServices.sourceFileProvider: SourceFileProvider by TestServices.testServiceAccessor()
@@ -28,6 +30,7 @@ val TestServices.sourceFileProvider: SourceFileProvider by TestServices.testServ
 class SourceFileProviderImpl(val testServices: TestServices, val preprocessors: List<SourceFilePreprocessor>) : SourceFileProvider() {
     override val kotlinSourceDirectory: File = testServices.createTempDirectory("kotlin-files")
     override val javaSourceDirectory: File = testServices.createTempDirectory("java-files")
+    override val javaBinaryDirectory: File = testServices.createTempDirectory("java-binary-files")
 
     private val contentOfFiles = mutableMapOf<TestFile, String>()
     private val realFileMap = mutableMapOf<TestFile, File>()
@@ -52,6 +55,20 @@ class SourceFileProviderImpl(val testServices: TestServices, val preprocessors:
         }
     }
 
+    override fun getRealFileForBinaryFile(testFile: TestFile): File {
+        return realFileMap.getOrPut(testFile) {
+            val directory = when {
+                testFile.isKtFile -> kotlinSourceDirectory
+                testFile.isJavaFile -> javaBinaryDirectory
+                else -> error("Unknown file type: ${testFile.name}")
+            }
+            directory.resolve(testFile.relativePath).also {
+                it.parentFile.mkdirs()
+                it.writeText(getContentOfSourceFile(testFile))
+            }
+        }
+    }
+
     private fun generateFinalContent(testFile: TestFile): String {
         return preprocessors.fold(testFile.originalContent) { content, preprocessor ->
             preprocessor.process(testFile, content)

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/AnnotatedBoundsOfWildcard.fir.kt

@@ -0,0 +1,90 @@
+// WITH_FOREIGN_ANNOTATIONS
+// JSPECIFY_STATE: strict
+
+// FILE: AnnotatedBoundsOfWildcard.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class AnnotatedBoundsOfWildcard {
+    public void superAsIs(Test<? super Base, ? super @Nullable Base, ? super @NullnessUnspecified Base> a) {}
+    public void superNotNull(Test<? super Base, ? super Base, ? super Base> a) {}
+    public void superNullable(Test<? super @Nullable Base, ? super @Nullable Base, ? super @Nullable Base> a) {}
+
+    public void extendsAsIs(Test<? extends Base, ? extends @Nullable Base, ? extends @NullnessUnspecified Base> a) {}
+    public void extendsNotNull(Test<? extends Base, ? extends Base, ? extends Base> a) {}
+    public void extendsNullable(Test<? extends @Nullable Base, ? extends @Nullable Base, ? extends @Nullable Base> a) {}
+
+    public void noBounds(Test<? extends @NullnessUnspecified Object, ? extends @NullnessUnspecified Object, ? extends @NullnessUnspecified Object> a) {}
+}
+
+// FILE: Base.java
+public class Base {}
+
+// FILE: Derived.java
+public class Derived extends Base {}
+
+// FILE: Test.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Test<T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> { }
+
+// FILE: main.kt
+fun main(
+            aNotNullNotNullNotNull: Test<Derived, Derived, Derived>,
+            aNotNullNotNullNull: Test<Derived, Derived, Derived?>,
+            aNotNullNullNotNull: Test<Derived, Derived?, Derived>,
+            aNotNullNullNull: Test<Derived, Derived?, Derived?>,
+
+            aAnyNotNullNotNullNotNull: Test<Any, Any, Any>,
+            aAnyNotNullNotNullNull: Test<Any, Any, Any?>,
+            aAnyNotNullNullNotNull: Test<Any, Any?, Any>,
+            aAnyNotNullNullNull: Test<Any, Any?, Any?>,
+
+            b: AnnotatedBoundsOfWildcard
+): Unit {
+    // jspecify_nullness_mismatch
+    b.superAsIs(<!TYPE_MISMATCH!>aAnyNotNullNotNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.superAsIs(<!TYPE_MISMATCH!>aAnyNotNullNotNullNull<!>)
+    b.superAsIs(aAnyNotNullNullNotNull)
+    b.superAsIs(aAnyNotNullNullNull)
+
+    b.superNotNull(aAnyNotNullNotNullNotNull)
+    b.superNotNull(aAnyNotNullNotNullNull)
+    b.superNotNull(aAnyNotNullNullNotNull)
+    b.superNotNull(aAnyNotNullNullNull)
+
+    // jspecify_nullness_mismatch
+    b.superNullable(<!TYPE_MISMATCH!>aAnyNotNullNotNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.superNullable(<!TYPE_MISMATCH!>aAnyNotNullNotNullNull<!>)
+    // jspecify_nullness_mismatch
+    b.superNullable(<!TYPE_MISMATCH!>aAnyNotNullNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.superNullable(<!TYPE_MISMATCH!>aAnyNotNullNullNull<!>)
+
+    b.extendsAsIs(aNotNullNotNullNotNull)
+    b.extendsAsIs(aNotNullNotNullNull)
+    b.extendsAsIs(aNotNullNullNotNull)
+    b.extendsAsIs(aNotNullNullNull)
+
+    b.extendsNotNull(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(<!TYPE_MISMATCH!>aNotNullNotNullNull<!>)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(<!TYPE_MISMATCH!>aNotNullNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(<!TYPE_MISMATCH!>aNotNullNullNull<!>)
+
+    b.extendsNullable(aNotNullNotNullNotNull)
+    b.extendsNullable(aNotNullNotNullNull)
+    b.extendsNullable(aNotNullNullNotNull)
+    b.extendsNullable(aNotNullNullNull)
+
+    b.noBounds(aNotNullNotNullNotNull)
+    b.noBounds(aNotNullNotNullNull)
+    b.noBounds(aNotNullNullNotNull)
+    b.noBounds(aNotNullNullNull)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/AnnotatedBoundsOfWildcard.fir.txt

@@ -0,0 +1,38 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: Test<Derived, Derived, Derived>, /*1*/ aNotNullNotNullNull: Test<Derived, Derived, Derived?>, /*2*/ aNotNullNullNotNull: Test<Derived, Derived?, Derived>, /*3*/ aNotNullNullNull: Test<Derived, Derived?, Derived?>, /*4*/ aAnyNotNullNotNullNotNull: Test<kotlin.Any, kotlin.Any, kotlin.Any>, /*5*/ aAnyNotNullNotNullNull: Test<kotlin.Any, kotlin.Any, kotlin.Any?>, /*6*/ aAnyNotNullNullNotNull: Test<kotlin.Any, kotlin.Any?, kotlin.Any>, /*7*/ aAnyNotNullNullNull: Test<kotlin.Any, kotlin.Any?, kotlin.Any?>, /*8*/ b: AnnotatedBoundsOfWildcard): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class AnnotatedBoundsOfWildcard {
+    public constructor AnnotatedBoundsOfWildcard()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun extendsAsIs(/*0*/ a: Test<out Base, out @org.jspecify.nullness.Nullable Base?, out @org.jspecify.nullness.NullnessUnspecified Base!>): kotlin.Unit
+    public open fun extendsNotNull(/*0*/ a: Test<out Base, out Base, out Base>): kotlin.Unit
+    public open fun extendsNullable(/*0*/ a: Test<out @org.jspecify.nullness.Nullable Base?, out @org.jspecify.nullness.Nullable Base?, out @org.jspecify.nullness.Nullable Base?>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun noBounds(/*0*/ a: Test<out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!, out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!, out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!>): kotlin.Unit
+    public open fun superAsIs(/*0*/ a: Test<in Base, in @org.jspecify.nullness.Nullable Base?, in @org.jspecify.nullness.NullnessUnspecified Base!>): kotlin.Unit
+    public open fun superNotNull(/*0*/ a: Test<in Base, in Base, in Base>): kotlin.Unit
+    public open fun superNullable(/*0*/ a: Test<in @org.jspecify.nullness.Nullable Base?, in @org.jspecify.nullness.Nullable Base?, in @org.jspecify.nullness.Nullable Base?>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Base {
+    public constructor Base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Derived : Base {
+    public constructor Derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class Test</*0*/ T : kotlin.Any, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!> {
+    public constructor Test</*0*/ T : kotlin.Any, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/AnnotatedBoundsOfWildcard.kt

@@ -0,0 +1,90 @@
+// WITH_FOREIGN_ANNOTATIONS
+// JSPECIFY_STATE: strict
+
+// FILE: AnnotatedBoundsOfWildcard.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class AnnotatedBoundsOfWildcard {
+    public void superAsIs(Test<? super Base, ? super @Nullable Base, ? super @NullnessUnspecified Base> a) {}
+    public void superNotNull(Test<? super Base, ? super Base, ? super Base> a) {}
+    public void superNullable(Test<? super @Nullable Base, ? super @Nullable Base, ? super @Nullable Base> a) {}
+
+    public void extendsAsIs(Test<? extends Base, ? extends @Nullable Base, ? extends @NullnessUnspecified Base> a) {}
+    public void extendsNotNull(Test<? extends Base, ? extends Base, ? extends Base> a) {}
+    public void extendsNullable(Test<? extends @Nullable Base, ? extends @Nullable Base, ? extends @Nullable Base> a) {}
+
+    public void noBounds(Test<? extends @NullnessUnspecified Object, ? extends @NullnessUnspecified Object, ? extends @NullnessUnspecified Object> a) {}
+}
+
+// FILE: Base.java
+public class Base {}
+
+// FILE: Derived.java
+public class Derived extends Base {}
+
+// FILE: Test.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Test<T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> { }
+
+// FILE: main.kt
+fun main(
+            aNotNullNotNullNotNull: Test<Derived, Derived, Derived>,
+            aNotNullNotNullNull: Test<Derived, Derived, Derived?>,
+            aNotNullNullNotNull: Test<Derived, Derived?, Derived>,
+            aNotNullNullNull: Test<Derived, Derived?, Derived?>,
+
+            aAnyNotNullNotNullNotNull: Test<Any, Any, Any>,
+            aAnyNotNullNotNullNull: Test<Any, Any, Any?>,
+            aAnyNotNullNullNotNull: Test<Any, Any?, Any>,
+            aAnyNotNullNullNull: Test<Any, Any?, Any?>,
+
+            b: AnnotatedBoundsOfWildcard
+): Unit {
+    // jspecify_nullness_mismatch
+    b.superAsIs(<!TYPE_MISMATCH!>aAnyNotNullNotNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.superAsIs(<!TYPE_MISMATCH!>aAnyNotNullNotNullNull<!>)
+    b.superAsIs(aAnyNotNullNullNotNull)
+    b.superAsIs(aAnyNotNullNullNull)
+
+    b.superNotNull(aAnyNotNullNotNullNotNull)
+    b.superNotNull(aAnyNotNullNotNullNull)
+    b.superNotNull(aAnyNotNullNullNotNull)
+    b.superNotNull(aAnyNotNullNullNull)
+
+    // jspecify_nullness_mismatch
+    b.superNullable(<!TYPE_MISMATCH!>aAnyNotNullNotNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.superNullable(<!TYPE_MISMATCH!>aAnyNotNullNotNullNull<!>)
+    // jspecify_nullness_mismatch
+    b.superNullable(<!TYPE_MISMATCH!>aAnyNotNullNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.superNullable(<!TYPE_MISMATCH!>aAnyNotNullNullNull<!>)
+
+    b.extendsAsIs(aNotNullNotNullNotNull)
+    b.extendsAsIs(aNotNullNotNullNull)
+    b.extendsAsIs(aNotNullNullNotNull)
+    b.extendsAsIs(aNotNullNullNull)
+
+    b.extendsNotNull(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(<!TYPE_MISMATCH!>aNotNullNotNullNull<!>)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(<!TYPE_MISMATCH!>aNotNullNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.extendsNotNull(<!TYPE_MISMATCH!>aNotNullNullNull<!>)
+
+    b.extendsNullable(aNotNullNotNullNotNull)
+    b.extendsNullable(aNotNullNotNullNull)
+    b.extendsNullable(aNotNullNullNotNull)
+    b.extendsNullable(aNotNullNullNull)
+
+    b.noBounds(aNotNullNotNullNotNull)
+    b.noBounds(aNotNullNotNullNull)
+    b.noBounds(aNotNullNullNotNull)
+    b.noBounds(aNotNullNullNull)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/AnnotatedBoundsOfWildcard.txt

@@ -0,0 +1,39 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: Test<Derived, Derived, Derived>, /*1*/ aNotNullNotNullNull: Test<Derived, Derived, Derived?>, /*2*/ aNotNullNullNotNull: Test<Derived, Derived?, Derived>, /*3*/ aNotNullNullNull: Test<Derived, Derived?, Derived?>, /*4*/ aAnyNotNullNotNullNotNull: Test<kotlin.Any, kotlin.Any, kotlin.Any>, /*5*/ aAnyNotNullNotNullNull: Test<kotlin.Any, kotlin.Any, kotlin.Any?>, /*6*/ aAnyNotNullNullNotNull: Test<kotlin.Any, kotlin.Any?, kotlin.Any>, /*7*/ aAnyNotNullNullNull: Test<kotlin.Any, kotlin.Any?, kotlin.Any?>, /*8*/ b: AnnotatedBoundsOfWildcard): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class AnnotatedBoundsOfWildcard {
+    public constructor AnnotatedBoundsOfWildcard()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun extendsAsIs(/*0*/ a: Test<out Base, out @org.jspecify.nullness.Nullable Base?, out @org.jspecify.nullness.NullnessUnspecified Base!>): kotlin.Unit
+    public open fun extendsNotNull(/*0*/ a: Test<out Base, out Base, out Base>): kotlin.Unit
+    public open fun extendsNullable(/*0*/ a: Test<out @org.jspecify.nullness.Nullable Base?, out @org.jspecify.nullness.Nullable Base?, out @org.jspecify.nullness.Nullable Base?>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun noBounds(/*0*/ a: Test<out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!, out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!, out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!>): kotlin.Unit
+    public open fun superAsIs(/*0*/ a: Test<in Base, in @org.jspecify.nullness.Nullable Base?, in @org.jspecify.nullness.NullnessUnspecified Base!>): kotlin.Unit
+    public open fun superNotNull(/*0*/ a: Test<in Base, in Base, in Base>): kotlin.Unit
+    public open fun superNullable(/*0*/ a: Test<in @org.jspecify.nullness.Nullable Base?, in @org.jspecify.nullness.Nullable Base?, in @org.jspecify.nullness.Nullable Base?>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Base {
+    public constructor Base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Derived : Base {
+    public constructor Derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class Test</*0*/ T : kotlin.Any, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!> {
+    public constructor Test</*0*/ T : kotlin.Any, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Defaults.fir.kt

@@ -0,0 +1,52 @@
+// WITH_FOREIGN_ANNOTATIONS
+// JSPECIFY_STATE: strict
+
+// FILE: Defaults.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Defaults {
+    public Foo defaultField = null;
+    @Nullable public Foo field = null;
+
+    public Foo everythingNotNullable(Foo x) { return null; }
+
+    public @Nullable Foo everythingNullable(@Nullable Foo x) { return null; }
+
+    public @NullnessUnspecified Foo everythingUnknown(@NullnessUnspecified Foo x) { return null; }
+
+    public @Nullable Foo mixed(Foo x) { return null; }
+
+    public Foo explicitlyNullnessUnspecified(@NullnessUnspecified Foo x) { return null; }
+}
+
+// FILE: Foo.java
+public class Foo {
+    public Object foo() { return null; }
+}
+
+// FILE: main.kt
+fun main(a: Defaults, x: Foo): Unit {
+    // jspecify_nullness_mismatch
+    a.everythingNotNullable(<!NULL_FOR_NONNULL_TYPE!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    // jspecify_nullness_mismatch
+    a.everythingNullable(null)<!UNSAFE_CALL!>.<!>foo()
+
+    a.everythingUnknown(null).foo()
+
+    // jspecify_nullness_mismatch
+    a.mixed(<!NULL_FOR_NONNULL_TYPE!>null<!>)<!UNSAFE_CALL!>.<!>foo()
+    // jspecify_nullness_mismatch
+    a.mixed(x)<!UNSAFE_CALL!>.<!>foo()
+
+    a.explicitlyNullnessUnspecified(x).foo()
+    a.explicitlyNullnessUnspecified(null).foo()
+
+    a.defaultField.foo()
+
+    // jspecify_nullness_mismatch
+    a.field<!UNSAFE_CALL!>.<!>foo()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Defaults.fir.txt

@@ -0,0 +1,25 @@
+package
+
+public fun main(/*0*/ a: Defaults, /*1*/ x: Foo): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class Defaults {
+    public constructor Defaults()
+    public final var defaultField: Foo
+    @org.jspecify.nullness.Nullable public final var field: @org.jspecify.nullness.Nullable Foo?
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun everythingNotNullable(/*0*/ x: Foo): Foo
+    @org.jspecify.nullness.Nullable public open fun everythingNullable(/*0*/ @org.jspecify.nullness.Nullable x: @org.jspecify.nullness.Nullable Foo?): @org.jspecify.nullness.Nullable Foo?
+    @org.jspecify.nullness.NullnessUnspecified public open fun everythingUnknown(/*0*/ @org.jspecify.nullness.NullnessUnspecified x: @org.jspecify.nullness.NullnessUnspecified Foo!): @org.jspecify.nullness.NullnessUnspecified Foo!
+    public open fun explicitlyNullnessUnspecified(/*0*/ @org.jspecify.nullness.NullnessUnspecified x: @org.jspecify.nullness.NullnessUnspecified Foo!): Foo
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    @org.jspecify.nullness.Nullable public open fun mixed(/*0*/ x: Foo): @org.jspecify.nullness.Nullable Foo?
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Foo {
+    public constructor Foo()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(): kotlin.Any!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Defaults.kt

@@ -0,0 +1,52 @@
+// WITH_FOREIGN_ANNOTATIONS
+// JSPECIFY_STATE: strict
+
+// FILE: Defaults.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Defaults {
+    public Foo defaultField = null;
+    @Nullable public Foo field = null;
+
+    public Foo everythingNotNullable(Foo x) { return null; }
+
+    public @Nullable Foo everythingNullable(@Nullable Foo x) { return null; }
+
+    public @NullnessUnspecified Foo everythingUnknown(@NullnessUnspecified Foo x) { return null; }
+
+    public @Nullable Foo mixed(Foo x) { return null; }
+
+    public Foo explicitlyNullnessUnspecified(@NullnessUnspecified Foo x) { return null; }
+}
+
+// FILE: Foo.java
+public class Foo {
+    public Object foo() { return null; }
+}
+
+// FILE: main.kt
+fun main(a: Defaults, x: Foo): Unit {
+    // jspecify_nullness_mismatch
+    a.everythingNotNullable(<!NULL_FOR_NONNULL_TYPE!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    // jspecify_nullness_mismatch
+    a.everythingNullable(null)<!UNSAFE_CALL!>.<!>foo()
+
+    a.everythingUnknown(null).foo()
+
+    // jspecify_nullness_mismatch
+    a.mixed(<!NULL_FOR_NONNULL_TYPE!>null<!>)<!UNSAFE_CALL!>.<!>foo()
+    // jspecify_nullness_mismatch
+    a.mixed(x)<!UNSAFE_CALL!>.<!>foo()
+
+    a.explicitlyNullnessUnspecified(x).foo()
+    a.explicitlyNullnessUnspecified(null).foo()
+
+    a.defaultField.foo()
+
+    // jspecify_nullness_mismatch
+    a.field<!UNSAFE_CALL!>.<!>foo()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Defaults.txt

@@ -0,0 +1,26 @@
+package
+
+public fun main(/*0*/ a: Defaults, /*1*/ x: Foo): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class Defaults {
+    public constructor Defaults()
+    public final var defaultField: Foo
+    @org.jspecify.nullness.Nullable public final var field: @org.jspecify.nullness.Nullable Foo?
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun everythingNotNullable(/*0*/ x: Foo): Foo
+    @org.jspecify.nullness.Nullable public open fun everythingNullable(/*0*/ @org.jspecify.nullness.Nullable x: @org.jspecify.nullness.Nullable Foo?): @org.jspecify.nullness.Nullable Foo?
+    @org.jspecify.nullness.NullnessUnspecified public open fun everythingUnknown(/*0*/ @org.jspecify.nullness.NullnessUnspecified x: @org.jspecify.nullness.NullnessUnspecified Foo!): @org.jspecify.nullness.NullnessUnspecified Foo!
+    public open fun explicitlyNullnessUnspecified(/*0*/ @org.jspecify.nullness.NullnessUnspecified x: @org.jspecify.nullness.NullnessUnspecified Foo!): Foo
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    @org.jspecify.nullness.Nullable public open fun mixed(/*0*/ x: Foo): @org.jspecify.nullness.Nullable Foo?
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Foo {
+    public constructor Foo()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(): kotlin.Any!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/IgnoreAnnotations.fir.kt

@@ -0,0 +1,50 @@
+// WITH_FOREIGN_ANNOTATIONS
+// JSPECIFY_STATE: strict
+
+// FILE: IgnoreAnnotations.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class IgnoreAnnotations {
+    @Nullable public Derived field = null;
+
+    @Nullable
+    public Derived foo(Derived x, @NullnessUnspecified Base y) {
+        return null;
+    }
+
+    public Derived everythingNotNullable(Derived x) { return null; }
+
+    public @Nullable Derived everythingNullable(@Nullable Derived x) { return null; }
+
+    public @NullnessUnspecified Derived everythingUnknown(@NullnessUnspecified Derived x) { return null; }
+}
+
+// FILE: Base.java
+public class Base {
+    void foo() {}
+}
+
+// FILE: Derived.java
+public class Derived extends Base { }
+
+// FILE: main.kt
+fun main(a: IgnoreAnnotations, x: Derived): Unit {
+    // jspecify_nullness_mismatch
+    a.foo(x, null)<!UNSAFE_CALL!>.<!>foo()
+    // jspecify_nullness_mismatch
+    a.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>, x)<!UNSAFE_CALL!>.<!>foo()
+
+    // jspecify_nullness_mismatch
+    a.field<!UNSAFE_CALL!>.<!>foo()
+
+    // jspecify_nullness_mismatch
+    a.everythingNotNullable(<!NULL_FOR_NONNULL_TYPE!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    // jspecify_nullness_mismatch
+    a.everythingNullable(null)<!UNSAFE_CALL!>.<!>foo()
+
+    a.everythingUnknown(null).foo()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/IgnoreAnnotations.fir.txt

@@ -0,0 +1,31 @@
+package
+
+public fun main(/*0*/ a: IgnoreAnnotations, /*1*/ x: Derived): kotlin.Unit
+
+public open class Base {
+    public constructor Base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Derived : Base {
+    public constructor Derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open override /*1*/ /*fake_override*/ fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class IgnoreAnnotations {
+    public constructor IgnoreAnnotations()
+    @org.jspecify.nullness.Nullable public final var field: @org.jspecify.nullness.Nullable Derived?
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun everythingNotNullable(/*0*/ x: Derived): Derived
+    @org.jspecify.nullness.Nullable public open fun everythingNullable(/*0*/ @org.jspecify.nullness.Nullable x: @org.jspecify.nullness.Nullable Derived?): @org.jspecify.nullness.Nullable Derived?
+    @org.jspecify.nullness.NullnessUnspecified public open fun everythingUnknown(/*0*/ @org.jspecify.nullness.NullnessUnspecified x: @org.jspecify.nullness.NullnessUnspecified Derived!): @org.jspecify.nullness.NullnessUnspecified Derived!
+    @org.jspecify.nullness.Nullable public open fun foo(/*0*/ x: Derived, /*1*/ @org.jspecify.nullness.NullnessUnspecified y: @org.jspecify.nullness.NullnessUnspecified Base!): @org.jspecify.nullness.Nullable Derived?
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/IgnoreAnnotations.kt

@@ -0,0 +1,50 @@
+// WITH_FOREIGN_ANNOTATIONS
+// JSPECIFY_STATE: strict
+
+// FILE: IgnoreAnnotations.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class IgnoreAnnotations {
+    @Nullable public Derived field = null;
+
+    @Nullable
+    public Derived foo(Derived x, @NullnessUnspecified Base y) {
+        return null;
+    }
+
+    public Derived everythingNotNullable(Derived x) { return null; }
+
+    public @Nullable Derived everythingNullable(@Nullable Derived x) { return null; }
+
+    public @NullnessUnspecified Derived everythingUnknown(@NullnessUnspecified Derived x) { return null; }
+}
+
+// FILE: Base.java
+public class Base {
+    void foo() {}
+}
+
+// FILE: Derived.java
+public class Derived extends Base { }
+
+// FILE: main.kt
+fun main(a: IgnoreAnnotations, x: Derived): Unit {
+    // jspecify_nullness_mismatch
+    a.foo(x, null)<!UNSAFE_CALL!>.<!>foo()
+    // jspecify_nullness_mismatch
+    a.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>, x)<!UNSAFE_CALL!>.<!>foo()
+
+    // jspecify_nullness_mismatch
+    a.field<!UNSAFE_CALL!>.<!>foo()
+
+    // jspecify_nullness_mismatch
+    a.everythingNotNullable(<!NULL_FOR_NONNULL_TYPE!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    // jspecify_nullness_mismatch
+    a.everythingNullable(null)<!UNSAFE_CALL!>.<!>foo()
+
+    a.everythingUnknown(null).foo()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/IgnoreAnnotations.txt

@@ -0,0 +1,32 @@
+package
+
+public fun main(/*0*/ a: IgnoreAnnotations, /*1*/ x: Derived): kotlin.Unit
+
+public open class Base {
+    public constructor Base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Derived : Base {
+    public constructor Derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open override /*1*/ /*fake_override*/ fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class IgnoreAnnotations {
+    public constructor IgnoreAnnotations()
+    @org.jspecify.nullness.Nullable public final var field: @org.jspecify.nullness.Nullable Derived?
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun everythingNotNullable(/*0*/ x: Derived): Derived
+    @org.jspecify.nullness.Nullable public open fun everythingNullable(/*0*/ @org.jspecify.nullness.Nullable x: @org.jspecify.nullness.Nullable Derived?): @org.jspecify.nullness.Nullable Derived?
+    @org.jspecify.nullness.NullnessUnspecified public open fun everythingUnknown(/*0*/ @org.jspecify.nullness.NullnessUnspecified x: @org.jspecify.nullness.NullnessUnspecified Derived!): @org.jspecify.nullness.NullnessUnspecified Derived!
+    @org.jspecify.nullness.Nullable public open fun foo(/*0*/ x: Derived, /*1*/ @org.jspecify.nullness.NullnessUnspecified y: @org.jspecify.nullness.NullnessUnspecified Base!): @org.jspecify.nullness.Nullable Derived?
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NonPlatformTypeParameter.fir.kt

@@ -0,0 +1,31 @@
+// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// WITH_FOREIGN_ANNOTATIONS
+// JSPECIFY_STATE: strict
+
+// FILE: NonPlatformTypeParameter.java
+
+import org.jspecify.nullness.*;
+
+public class NonPlatformTypeParameter<T extends @Nullable Object> {
+    public void foo(T t) {}
+    public <E extends @Nullable Object> void bar(E e) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+fun <T : Test> main(a1: NonPlatformTypeParameter<Any?>, a2: NonPlatformTypeParameter<Test>, x: T): Unit {
+    a1.foo(null)
+    a1.bar<Test?>(null)
+    // jspecify_nullness_mismatch
+    a1.bar<T>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    a2.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.bar<Test?>(null)
+    // jspecify_nullness_mismatch
+    a2.bar<T>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.bar<T>(x)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NonPlatformTypeParameter.fir.txt

@@ -0,0 +1,19 @@
+package
+
+public fun </*0*/ T : Test> main(/*0*/ a1: NonPlatformTypeParameter<kotlin.Any?>, /*1*/ a2: NonPlatformTypeParameter<Test>, /*2*/ x: T): kotlin.Unit
+
+public open class NonPlatformTypeParameter</*0*/ T> {
+    public constructor NonPlatformTypeParameter</*0*/ T>()
+    public open fun </*0*/ E> bar(/*0*/ e: E): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NonPlatformTypeParameter.kt

@@ -0,0 +1,31 @@
+// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// WITH_FOREIGN_ANNOTATIONS
+// JSPECIFY_STATE: strict
+
+// FILE: NonPlatformTypeParameter.java
+
+import org.jspecify.nullness.*;
+
+public class NonPlatformTypeParameter<T extends @Nullable Object> {
+    public void foo(T t) {}
+    public <E extends @Nullable Object> void bar(E e) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+fun <T : Test> main(a1: NonPlatformTypeParameter<Any?>, a2: NonPlatformTypeParameter<Test>, x: T): Unit {
+    a1.foo(null)
+    a1.bar<Test?>(null)
+    // jspecify_nullness_mismatch
+    a1.bar<T>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    a2.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.bar<Test?>(null)
+    // jspecify_nullness_mismatch
+    a2.bar<T>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.bar<T>(x)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NonPlatformTypeParameter.txt

@@ -0,0 +1,20 @@
+package
+
+public fun </*0*/ T : Test> main(/*0*/ a1: NonPlatformTypeParameter<kotlin.Any?>, /*1*/ a2: NonPlatformTypeParameter<Test>, /*2*/ x: T): kotlin.Unit
+
+public open class NonPlatformTypeParameter</*0*/ T> {
+    public constructor NonPlatformTypeParameter</*0*/ T>()
+    public open fun </*0*/ E> bar(/*0*/ e: E): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NullnessUnspecifiedTypeParameter.fir.kt

@@ -0,0 +1,40 @@
+// WITH_FOREIGN_ANNOTATIONS
+// JSPECIFY_STATE: strict
+
+// FILE: NullnessUnspecifiedTypeParameter.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class NullnessUnspecifiedTypeParameter<T> {
+    public void foo(T t) {}
+
+    public void bar(Test s, T t) {} // t should not become not nullable
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+// jspecify_nullness_mismatch
+fun main(a1: NullnessUnspecifiedTypeParameter<Any>, a2: NullnessUnspecifiedTypeParameter<<!UPPER_BOUND_VIOLATED!>Any?<!>>, x: Test): Unit {
+    // jspecify_nullness_mismatch
+    a1.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.foo(1)
+
+    // jspecify_nullness_mismatch
+    a2.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.foo(1)
+
+    // jspecify_nullness_mismatch
+    a1.bar(<!NULL_FOR_NONNULL_TYPE!>null<!>, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    // jspecify_nullness_mismatch
+    a1.bar(x, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.bar(x, 1)
+
+    // jspecify_nullness_mismatch
+    a2.bar(<!NULL_FOR_NONNULL_TYPE!>null<!>, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    // jspecify_nullness_mismatch
+    a2.bar(x, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.bar(x, 1)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NullnessUnspecifiedTypeParameter.fir.txt

@@ -0,0 +1,19 @@
+package
+
+public fun main(/*0*/ a1: NullnessUnspecifiedTypeParameter<kotlin.Any>, /*1*/ a2: NullnessUnspecifiedTypeParameter<kotlin.Any?>, /*2*/ x: Test): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class NullnessUnspecifiedTypeParameter</*0*/ T : kotlin.Any> {
+    public constructor NullnessUnspecifiedTypeParameter</*0*/ T : kotlin.Any>()
+    public open fun bar(/*0*/ s: Test, /*1*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NullnessUnspecifiedTypeParameter.kt

@@ -0,0 +1,40 @@
+// WITH_FOREIGN_ANNOTATIONS
+// JSPECIFY_STATE: strict
+
+// FILE: NullnessUnspecifiedTypeParameter.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class NullnessUnspecifiedTypeParameter<T> {
+    public void foo(T t) {}
+
+    public void bar(Test s, T t) {} // t should not become not nullable
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+// jspecify_nullness_mismatch
+fun main(a1: NullnessUnspecifiedTypeParameter<Any>, a2: NullnessUnspecifiedTypeParameter<<!UPPER_BOUND_VIOLATED!>Any?<!>>, x: Test): Unit {
+    // jspecify_nullness_mismatch
+    a1.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.foo(1)
+
+    // jspecify_nullness_mismatch
+    a2.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.foo(1)
+
+    // jspecify_nullness_mismatch
+    a1.bar(<!NULL_FOR_NONNULL_TYPE!>null<!>, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    // jspecify_nullness_mismatch
+    a1.bar(x, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.bar(x, 1)
+
+    // jspecify_nullness_mismatch
+    a2.bar(<!NULL_FOR_NONNULL_TYPE!>null<!>, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    // jspecify_nullness_mismatch
+    a2.bar(x, <!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.bar(x, 1)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/NullnessUnspecifiedTypeParameter.txt

@@ -0,0 +1,20 @@
+package
+
+public fun main(/*0*/ a1: NullnessUnspecifiedTypeParameter<kotlin.Any>, /*1*/ a2: NullnessUnspecifiedTypeParameter<kotlin.Any?>, /*2*/ x: Test): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class NullnessUnspecifiedTypeParameter</*0*/ T : kotlin.Any> {
+    public constructor NullnessUnspecifiedTypeParameter</*0*/ T : kotlin.Any>()
+    public open fun bar(/*0*/ s: Test, /*1*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/SelfType.fir.kt

@@ -0,0 +1,59 @@
+// WITH_FOREIGN_ANNOTATIONS
+// JSPECIFY_STATE: strict
+
+// FILE: SelfType.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class SelfType<T extends SelfType<T>> {
+    public void foo(T t) {}
+}
+
+// FILE: B.java
+public class B extends SelfType<B> {}
+
+// FILE: C.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class C<E extends C<E>> extends SelfType<E> {}
+
+// FILE: AK.java
+public class AK extends SelfType<AK> {}
+
+// FILE: AKN.java
+import org.jspecify.nullness.*;
+
+public class AKN extends SelfType<@Nullable AK> {}
+
+// FILE: BK.java
+public class BK extends B {}
+
+// FILE: CK.java
+public class CK extends C<CK> {}
+
+// FILE: CKN.java
+import org.jspecify.nullness.*;
+
+public class CKN extends C<@Nullable CK> {}
+
+// FILE: main.kt
+fun main(ak: AK, akn: AKN, bk: BK, ck: CK, ckn: CKN): Unit {
+    ak.foo(ak)
+    // jspecify_nullness_mismatch
+    ak.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    // jspecify_nullness_mismatch
+    akn.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    bk.foo(bk)
+    // jspecify_nullness_mismatch
+    bk.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    ck.foo(ck)
+    // jspecify_nullness_mismatch
+    ck.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    // jspecify_nullness_mismatch
+    ckn.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/SelfType.fir.txt

@@ -0,0 +1,67 @@
+package
+
+public fun main(/*0*/ ak: AK, /*1*/ akn: AKN, /*2*/ bk: BK, /*3*/ ck: CK, /*4*/ ckn: CKN): kotlin.Unit
+
+public open class AK : SelfType<AK!> {
+    public constructor AK()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: AK): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class AKN : SelfType<@org.jspecify.nullness.Nullable AK!> {
+    public constructor AKN()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: @org.jspecify.nullness.Nullable AK): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class B : SelfType<B!> {
+    public constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: B): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class BK : B {
+    public constructor BK()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: B): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class C</*0*/ E : C<E!>> : SelfType<E!> {
+    public constructor C</*0*/ E : C<E!>>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: E): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class CK : C<CK!> {
+    public constructor CK()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: CK): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class CKN : C<@org.jspecify.nullness.Nullable CK!> {
+    public constructor CKN()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: @org.jspecify.nullness.Nullable CK): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class SelfType</*0*/ T : SelfType<T!>> {
+    public constructor SelfType</*0*/ T : SelfType<T!>>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/SelfType.kt

@@ -0,0 +1,59 @@
+// WITH_FOREIGN_ANNOTATIONS
+// JSPECIFY_STATE: strict
+
+// FILE: SelfType.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class SelfType<T extends SelfType<T>> {
+    public void foo(T t) {}
+}
+
+// FILE: B.java
+public class B extends SelfType<B> {}
+
+// FILE: C.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class C<E extends C<E>> extends SelfType<E> {}
+
+// FILE: AK.java
+public class AK extends SelfType<AK> {}
+
+// FILE: AKN.java
+import org.jspecify.nullness.*;
+
+public class AKN extends SelfType<@Nullable AK> {}
+
+// FILE: BK.java
+public class BK extends B {}
+
+// FILE: CK.java
+public class CK extends C<CK> {}
+
+// FILE: CKN.java
+import org.jspecify.nullness.*;
+
+public class CKN extends C<@Nullable CK> {}
+
+// FILE: main.kt
+fun main(ak: AK, akn: AKN, bk: BK, ck: CK, ckn: CKN): Unit {
+    ak.foo(ak)
+    // jspecify_nullness_mismatch
+    ak.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    // jspecify_nullness_mismatch
+    akn.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    bk.foo(bk)
+    // jspecify_nullness_mismatch
+    bk.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    ck.foo(ck)
+    // jspecify_nullness_mismatch
+    ck.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+
+    // jspecify_nullness_mismatch
+    ckn.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/SelfType.txt

@@ -0,0 +1,68 @@
+package
+
+public fun main(/*0*/ ak: AK, /*1*/ akn: AKN, /*2*/ bk: BK, /*3*/ ck: CK, /*4*/ ckn: CKN): kotlin.Unit
+
+public open class AK : SelfType<AK!> {
+    public constructor AK()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: AK): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class AKN : SelfType<@org.jspecify.nullness.Nullable AK!> {
+    public constructor AKN()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: @org.jspecify.nullness.Nullable AK): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class B : SelfType<B!> {
+    public constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: B): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class BK : B {
+    public constructor BK()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: B): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class C</*0*/ E : C<E!>> : SelfType<E!> {
+    public constructor C</*0*/ E : C<E!>>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: E): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class CK : C<CK!> {
+    public constructor CK()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: CK): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class CKN : C<@org.jspecify.nullness.Nullable CK!> {
+    public constructor CKN()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: @org.jspecify.nullness.Nullable CK): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class SelfType</*0*/ T : SelfType<T!>> {
+    public constructor SelfType</*0*/ T : SelfType<T!>>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Simple.fir.kt

@@ -0,0 +1,41 @@
+// WITH_FOREIGN_ANNOTATIONS
+// JSPECIFY_STATE: strict
+
+// FILE: Simple.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Simple {
+    @Nullable public Derived field = null;
+
+    @Nullable
+    public Derived foo(Derived x, @NullnessUnspecified Base y) {
+        return null;
+    }
+
+    public Derived bar() {
+        return null;
+    }
+}
+
+// FILE: Base.java
+public class Base {}
+
+// FILE: Derived.java
+public class Derived extends Base {
+    void foo() {}
+}
+
+// FILE: main.kt
+fun main(a: Simple, x: Derived): Unit {
+    // jspecify_nullness_mismatch
+    a.foo(x, null)<!UNSAFE_CALL!>.<!>foo()
+    // jspecify_nullness_mismatch
+    a.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>, x)<!UNSAFE_CALL!>.<!>foo()
+
+    a.bar().foo()
+
+    // jspecify_nullness_mismatch
+    a.field<!UNSAFE_CALL!>.<!>foo()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Simple.fir.txt

@@ -0,0 +1,28 @@
+package
+
+public fun main(/*0*/ a: Simple, /*1*/ x: Derived): kotlin.Unit
+
+public open class Base {
+    public constructor Base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Derived : Base {
+    public constructor Derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class Simple {
+    public constructor Simple()
+    @org.jspecify.nullness.Nullable public final var field: @org.jspecify.nullness.Nullable Derived?
+    public open fun bar(): Derived
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    @org.jspecify.nullness.Nullable public open fun foo(/*0*/ x: Derived, /*1*/ @org.jspecify.nullness.NullnessUnspecified y: @org.jspecify.nullness.NullnessUnspecified Base!): @org.jspecify.nullness.Nullable Derived?
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Simple.kt

@@ -0,0 +1,41 @@
+// WITH_FOREIGN_ANNOTATIONS
+// JSPECIFY_STATE: strict
+
+// FILE: Simple.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Simple {
+    @Nullable public Derived field = null;
+
+    @Nullable
+    public Derived foo(Derived x, @NullnessUnspecified Base y) {
+        return null;
+    }
+
+    public Derived bar() {
+        return null;
+    }
+}
+
+// FILE: Base.java
+public class Base {}
+
+// FILE: Derived.java
+public class Derived extends Base {
+    void foo() {}
+}
+
+// FILE: main.kt
+fun main(a: Simple, x: Derived): Unit {
+    // jspecify_nullness_mismatch
+    a.foo(x, null)<!UNSAFE_CALL!>.<!>foo()
+    // jspecify_nullness_mismatch
+    a.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>, x)<!UNSAFE_CALL!>.<!>foo()
+
+    a.bar().foo()
+
+    // jspecify_nullness_mismatch
+    a.field<!UNSAFE_CALL!>.<!>foo()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/Simple.txt

@@ -0,0 +1,29 @@
+package
+
+public fun main(/*0*/ a: Simple, /*1*/ x: Derived): kotlin.Unit
+
+public open class Base {
+    public constructor Base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Derived : Base {
+    public constructor Derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public/*package*/ open fun foo(): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class Simple {
+    public constructor Simple()
+    @org.jspecify.nullness.Nullable public final var field: @org.jspecify.nullness.Nullable Derived?
+    public open fun bar(): Derived
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    @org.jspecify.nullness.Nullable public open fun foo(/*0*/ x: Derived, /*1*/ @org.jspecify.nullness.NullnessUnspecified y: @org.jspecify.nullness.NullnessUnspecified Base!): @org.jspecify.nullness.Nullable Derived?
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/TypeArgumentsFromParameterBounds.fir.kt

@@ -0,0 +1,50 @@
+// WITH_FOREIGN_ANNOTATIONS
+// JSPECIFY_STATE: strict
+
+// FILE: TypeArgumentsFromParameterBounds.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class TypeArgumentsFromParameterBounds<T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> {}
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class A {
+    public void bar(TypeArgumentsFromParameterBounds<Test, Test, Test> a) {}
+}
+
+// FILE: B.java
+import org.jspecify.nullness.*;
+
+public class B {
+    public void bar(TypeArgumentsFromParameterBounds<Test, Test, Test> a) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+fun main(
+    aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test, Test, Test>,
+    aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test, Test, Test?>,
+    aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test, Test?, Test>,
+    aNotNullNullNull: TypeArgumentsFromParameterBounds<Test, Test?, Test?>,
+    a: A, b: B
+): Unit {
+    a.bar(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    a.bar(<!TYPE_MISMATCH!>aNotNullNotNullNull<!>)
+    // jspecify_nullness_mismatch
+    a.bar(<!TYPE_MISMATCH!>aNotNullNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    a.bar(<!TYPE_MISMATCH!>aNotNullNullNull<!>)
+
+    // jspecify_nullness_mismatch
+    b.bar(<!TYPE_MISMATCH!>aNotNullNotNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.bar(<!TYPE_MISMATCH!>aNotNullNotNullNull<!>)
+    b.bar(aNotNullNullNotNull)
+    b.bar(aNotNullNullNull)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/TypeArgumentsFromParameterBounds.fir.txt

@@ -0,0 +1,33 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test, Test, Test>, /*1*/ aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test, Test, Test?>, /*2*/ aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test, Test?, Test>, /*3*/ aNotNullNullNull: TypeArgumentsFromParameterBounds<Test, Test?, Test?>, /*4*/ a: A, /*5*/ b: B): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class A {
+    public constructor A()
+    public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<Test, Test, Test>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class B {
+    public constructor B()
+    public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<Test, Test?, Test!>!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class TypeArgumentsFromParameterBounds</*0*/ T : kotlin.Any, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!> {
+    public constructor TypeArgumentsFromParameterBounds</*0*/ T : kotlin.Any, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/TypeArgumentsFromParameterBounds.kt

@@ -0,0 +1,50 @@
+// WITH_FOREIGN_ANNOTATIONS
+// JSPECIFY_STATE: strict
+
+// FILE: TypeArgumentsFromParameterBounds.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class TypeArgumentsFromParameterBounds<T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> {}
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class A {
+    public void bar(TypeArgumentsFromParameterBounds<Test, Test, Test> a) {}
+}
+
+// FILE: B.java
+import org.jspecify.nullness.*;
+
+public class B {
+    public void bar(TypeArgumentsFromParameterBounds<Test, Test, Test> a) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+fun main(
+    aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test, Test, Test>,
+    aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test, Test, Test?>,
+    aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test, Test?, Test>,
+    aNotNullNullNull: TypeArgumentsFromParameterBounds<Test, Test?, Test?>,
+    a: A, b: B
+): Unit {
+    a.bar(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    a.bar(<!TYPE_MISMATCH!>aNotNullNotNullNull<!>)
+    // jspecify_nullness_mismatch
+    a.bar(<!TYPE_MISMATCH!>aNotNullNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    a.bar(<!TYPE_MISMATCH!>aNotNullNullNull<!>)
+
+    // jspecify_nullness_mismatch
+    b.bar(<!TYPE_MISMATCH!>aNotNullNotNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.bar(<!TYPE_MISMATCH!>aNotNullNotNullNull<!>)
+    b.bar(aNotNullNullNotNull)
+    b.bar(aNotNullNullNull)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/TypeArgumentsFromParameterBounds.txt

@@ -0,0 +1,34 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test, Test, Test>, /*1*/ aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test, Test, Test?>, /*2*/ aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test, Test?, Test>, /*3*/ aNotNullNullNull: TypeArgumentsFromParameterBounds<Test, Test?, Test?>, /*4*/ a: A, /*5*/ b: B): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class A {
+    public constructor A()
+    public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<Test, Test, Test>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class B {
+    public constructor B()
+    public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<Test, Test?, Test!>!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class TypeArgumentsFromParameterBounds</*0*/ T : kotlin.Any, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!> {
+    public constructor TypeArgumentsFromParameterBounds</*0*/ T : kotlin.Any, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/TypeParameterBounds.fir.kt

@@ -0,0 +1,48 @@
+// WITH_FOREIGN_ANNOTATIONS
+// JSPECIFY_STATE: strict
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class A<T> {
+    public void foo(@NullnessUnspecified T t) {}
+    public <E> void bar(E e) {}
+}
+
+// FILE: B.java
+import org.jspecify.nullness.*;
+@NullMarked
+public class B<T> {
+    public void foo(T t) {}
+    public <E> void bar(E e) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+// jspecify_nullness_mismatch
+fun <T : Test> main(a1: A<<!UPPER_BOUND_VIOLATED!>Any?<!>>, a2: A<Test>, b1: B<<!UPPER_BOUND_VIOLATED!>Any?<!>>, b2: B<Test>, x: T): Unit {
+    a1.foo(null)
+    // jspecify_nullness_mismatch
+    a1.bar<<!UPPER_BOUND_VIOLATED!>T?<!>>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.bar<T>(x)
+
+    a2.foo(null)
+    // jspecify_nullness_mismatch
+    a2.bar<<!UPPER_BOUND_VIOLATED!>T?<!>>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    b1.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    // jspecify_nullness_mismatch
+    b1.bar<<!UPPER_BOUND_VIOLATED!>T?<!>>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    b1.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    b2.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    // jspecify_nullness_mismatch
+    b2.bar<<!UPPER_BOUND_VIOLATED!>T?<!>>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    b2.bar<T>(x)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/TypeParameterBounds.fir.txt

@@ -0,0 +1,28 @@
+package
+
+public fun </*0*/ T : Test> main(/*0*/ a1: A<kotlin.Any?>, /*1*/ a2: A<Test>, /*2*/ b1: B<kotlin.Any?>, /*3*/ b2: B<Test>, /*4*/ x: T): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class A</*0*/ T : kotlin.Any> {
+    public constructor A</*0*/ T : kotlin.Any>()
+    public open fun </*0*/ E : kotlin.Any> bar(/*0*/ e: E): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ @org.jspecify.nullness.NullnessUnspecified t: @org.jspecify.nullness.NullnessUnspecified T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class B</*0*/ T : kotlin.Any> {
+    public constructor B</*0*/ T : kotlin.Any>()
+    public open fun </*0*/ E : kotlin.Any> bar(/*0*/ e: E): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/TypeParameterBounds.kt

@@ -0,0 +1,48 @@
+// WITH_FOREIGN_ANNOTATIONS
+// JSPECIFY_STATE: strict
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class A<T> {
+    public void foo(@NullnessUnspecified T t) {}
+    public <E> void bar(E e) {}
+}
+
+// FILE: B.java
+import org.jspecify.nullness.*;
+@NullMarked
+public class B<T> {
+    public void foo(T t) {}
+    public <E> void bar(E e) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+// jspecify_nullness_mismatch
+fun <T : Test> main(a1: A<<!UPPER_BOUND_VIOLATED!>Any?<!>>, a2: A<Test>, b1: B<<!UPPER_BOUND_VIOLATED!>Any?<!>>, b2: B<Test>, x: T): Unit {
+    a1.foo(null)
+    // jspecify_nullness_mismatch
+    a1.bar<<!UPPER_BOUND_VIOLATED!>T?<!>>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a1.bar<T>(x)
+
+    a2.foo(null)
+    // jspecify_nullness_mismatch
+    a2.bar<<!UPPER_BOUND_VIOLATED!>T?<!>>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    a2.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    b1.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    // jspecify_nullness_mismatch
+    b1.bar<<!UPPER_BOUND_VIOLATED!>T?<!>>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    b1.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    b2.foo(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    // jspecify_nullness_mismatch
+    b2.bar<<!UPPER_BOUND_VIOLATED!>T?<!>>(<!NULL_FOR_NONNULL_TYPE!>null<!>)
+    b2.bar<T>(x)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/TypeParameterBounds.txt

@@ -0,0 +1,29 @@
+package
+
+public fun </*0*/ T : Test> main(/*0*/ a1: A<kotlin.Any?>, /*1*/ a2: A<Test>, /*2*/ b1: B<kotlin.Any?>, /*3*/ b2: B<Test>, /*4*/ x: T): kotlin.Unit
+
+@org.jspecify.nullness.NullMarked public open class A</*0*/ T : kotlin.Any> {
+    public constructor A</*0*/ T : kotlin.Any>()
+    public open fun </*0*/ E : kotlin.Any> bar(/*0*/ e: E): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ @org.jspecify.nullness.NullnessUnspecified t: @org.jspecify.nullness.NullnessUnspecified T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class B</*0*/ T : kotlin.Any> {
+    public constructor B</*0*/ T : kotlin.Any>()
+    public open fun </*0*/ E : kotlin.Any> bar(/*0*/ e: E): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class Test {
+    public constructor Test()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/WildcardsWithDefault.fir.kt

@@ -0,0 +1,39 @@
+// WITH_FOREIGN_ANNOTATIONS
+// JSPECIFY_STATE: strict
+
+// FILE: WildcardsWithDefault.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class WildcardsWithDefault {
+    public void noBoundsNotNull(A<?, ?, ?> a) {}
+    public void noBoundsNullable(A<? extends @Nullable Object, ? extends @Nullable Object, ? extends @Nullable Object> a) {}
+}
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+public class A <T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> {}
+
+// FILE: main.kt
+fun main(
+            aNotNullNotNullNotNull: A<Any, Any, Any>,
+            aNotNullNotNullNull: A<Any, Any, Any?>,
+            aNotNullNullNotNull: A<Any, Any?, Any>,
+            aNotNullNullNull: A<Any, Any?, Any?>,
+            b: WildcardsWithDefault
+): Unit {
+    b.noBoundsNotNull(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(<!TYPE_MISMATCH!>aNotNullNotNullNull<!>)
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(<!TYPE_MISMATCH!>aNotNullNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(<!TYPE_MISMATCH!>aNotNullNullNull<!>)
+
+    b.noBoundsNullable(aNotNullNotNullNotNull)
+    b.noBoundsNullable(aNotNullNotNullNull)
+    b.noBoundsNullable(aNotNullNullNotNull)
+    b.noBoundsNullable(aNotNullNullNull)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/WildcardsWithDefault.fir.txt

@@ -0,0 +1,19 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: A<kotlin.Any, kotlin.Any, kotlin.Any>, /*1*/ aNotNullNotNullNull: A<kotlin.Any, kotlin.Any, kotlin.Any?>, /*2*/ aNotNullNullNotNull: A<kotlin.Any, kotlin.Any?, kotlin.Any>, /*3*/ aNotNullNullNull: A<kotlin.Any, kotlin.Any?, kotlin.Any?>, /*4*/ b: WildcardsWithDefault): kotlin.Unit
+
+public open class A</*0*/ T : kotlin.Any!, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!> {
+    public constructor A</*0*/ T : kotlin.Any!, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class WildcardsWithDefault {
+    public constructor WildcardsWithDefault()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun noBoundsNotNull(/*0*/ a: A<out kotlin.Any, out @org.jspecify.nullness.Nullable kotlin.Any, out @org.jspecify.nullness.NullnessUnspecified kotlin.Any>): kotlin.Unit
+    public open fun noBoundsNullable(/*0*/ a: A<out @org.jspecify.nullness.Nullable kotlin.Any?, out @org.jspecify.nullness.Nullable kotlin.Any?, out @org.jspecify.nullness.Nullable kotlin.Any?>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/WildcardsWithDefault.kt

@@ -0,0 +1,39 @@
+// WITH_FOREIGN_ANNOTATIONS
+// JSPECIFY_STATE: strict
+
+// FILE: WildcardsWithDefault.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class WildcardsWithDefault {
+    public void noBoundsNotNull(A<?, ?, ?> a) {}
+    public void noBoundsNullable(A<? extends @Nullable Object, ? extends @Nullable Object, ? extends @Nullable Object> a) {}
+}
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+public class A <T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> {}
+
+// FILE: main.kt
+fun main(
+            aNotNullNotNullNotNull: A<Any, Any, Any>,
+            aNotNullNotNullNull: A<Any, Any, Any?>,
+            aNotNullNullNotNull: A<Any, Any?, Any>,
+            aNotNullNullNull: A<Any, Any?, Any?>,
+            b: WildcardsWithDefault
+): Unit {
+    b.noBoundsNotNull(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(<!TYPE_MISMATCH!>aNotNullNotNullNull<!>)
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(<!TYPE_MISMATCH!>aNotNullNullNotNull<!>)
+    // jspecify_nullness_mismatch
+    b.noBoundsNotNull(<!TYPE_MISMATCH!>aNotNullNullNull<!>)
+
+    b.noBoundsNullable(aNotNullNotNullNotNull)
+    b.noBoundsNullable(aNotNullNotNullNull)
+    b.noBoundsNullable(aNotNullNullNotNull)
+    b.noBoundsNullable(aNotNullNullNull)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/strictMode/WildcardsWithDefault.txt

@@ -0,0 +1,20 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: A<kotlin.Any, kotlin.Any, kotlin.Any>, /*1*/ aNotNullNotNullNull: A<kotlin.Any, kotlin.Any, kotlin.Any?>, /*2*/ aNotNullNullNotNull: A<kotlin.Any, kotlin.Any?, kotlin.Any>, /*3*/ aNotNullNullNull: A<kotlin.Any, kotlin.Any?, kotlin.Any?>, /*4*/ b: WildcardsWithDefault): kotlin.Unit
+
+public open class A</*0*/ T : kotlin.Any!, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!> {
+    public constructor A</*0*/ T : kotlin.Any!, /*1*/ E, /*2*/ F : @org.jspecify.nullness.NullnessUnspecified kotlin.Any!>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class WildcardsWithDefault {
+    public constructor WildcardsWithDefault()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun noBoundsNotNull(/*0*/ a: A<out kotlin.Any, out @org.jspecify.nullness.Nullable kotlin.Any, out @org.jspecify.nullness.NullnessUnspecified kotlin.Any>): kotlin.Unit
+    public open fun noBoundsNullable(/*0*/ a: A<out @org.jspecify.nullness.Nullable kotlin.Any?, out @org.jspecify.nullness.Nullable kotlin.Any?, out @org.jspecify.nullness.Nullable kotlin.Any?>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/AnnotatedBoundsOfWildcard.fir.kt

@@ -1,6 +1,35 @@
-// JAVA_SOURCES: AnnotatedBoundsOfWildcard.java
-// JSPECIFY_STATE warn
+// WITH_FOREIGN_ANNOTATIONS
 
+// FILE: AnnotatedBoundsOfWildcard.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class AnnotatedBoundsOfWildcard {
+    public void superAsIs(Test<? super Base, ? super @Nullable Base, ? super @NullnessUnspecified Base> a) {}
+    public void superNotNull(Test<? super Base, ? super Base, ? super Base> a) {}
+    public void superNullable(Test<? super @Nullable Base, ? super @Nullable Base, ? super @Nullable Base> a) {}
+
+    public void extendsAsIs(Test<? extends Base, ? extends @Nullable Base, ? extends @NullnessUnspecified Base> a) {}
+    public void extendsNotNull(Test<? extends Base, ? extends Base, ? extends Base> a) {}
+    public void extendsNullable(Test<? extends @Nullable Base, ? extends @Nullable Base, ? extends @Nullable Base> a) {}
+
+    public void noBounds(Test<? extends @NullnessUnspecified Object, ? extends @NullnessUnspecified Object, ? extends @NullnessUnspecified Object> a) {}
+}
+
+// FILE: Base.java
+public class Base {}
+
+// FILE: Derived.java
+public class Derived extends Base {}
+
+// FILE: Test.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Test<T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> { }
+
+// FILE: main.kt
 fun main(
             aNotNullNotNullNotNull: Test<Derived, Derived, Derived>,
             aNotNullNotNullNull: Test<Derived, Derived, Derived?>,

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/AnnotatedBoundsOfWildcard.fir.txt

@@ -5,12 +5,12 @@ public fun main(/*0*/ aNotNullNotNullNotNull: Test<Derived, Derived, Derived>, /
 @org.jspecify.nullness.NullMarked public open class AnnotatedBoundsOfWildcard {
     public constructor AnnotatedBoundsOfWildcard()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open fun extendsAsIs(/*0*/ a: Test<out @org.jspecify.nullness.NullnessUnspecified Base!, out @org.jspecify.nullness.NullnessUnspecified Base!, out @org.jspecify.nullness.NullnessUnspecified Base!>!): kotlin.Unit
+    public open fun extendsAsIs(/*0*/ a: Test<out Base!, out @org.jspecify.nullness.Nullable Base!, out @org.jspecify.nullness.NullnessUnspecified Base!>!): kotlin.Unit
     public open fun extendsNotNull(/*0*/ a: Test<out Base!, out Base!, out Base!>!): kotlin.Unit
     public open fun extendsNullable(/*0*/ a: Test<out @org.jspecify.nullness.Nullable Base!, out @org.jspecify.nullness.Nullable Base!, out @org.jspecify.nullness.Nullable Base!>!): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open fun noBounds(/*0*/ a: Test<*, *, *>!): kotlin.Unit
-    public open fun superAsIs(/*0*/ a: Test<in @org.jspecify.nullness.NullnessUnspecified Base!, in @org.jspecify.nullness.NullnessUnspecified Base!, in @org.jspecify.nullness.NullnessUnspecified Base!>!): kotlin.Unit
+    public open fun noBounds(/*0*/ a: Test<out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!, out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!, out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!>!): kotlin.Unit
+    public open fun superAsIs(/*0*/ a: Test<in Base!, in @org.jspecify.nullness.Nullable Base!, in @org.jspecify.nullness.NullnessUnspecified Base!>!): kotlin.Unit
     public open fun superNotNull(/*0*/ a: Test<in Base!, in Base!, in Base!>!): kotlin.Unit
     public open fun superNullable(/*0*/ a: Test<in @org.jspecify.nullness.Nullable Base!, in @org.jspecify.nullness.Nullable Base!, in @org.jspecify.nullness.Nullable Base!>!): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
@@ -36,11 +36,3 @@ public open class Derived : Base {
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
-
-@org.jspecify.nullness.NullMarked public open class Use {
-    public constructor Use()
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open fun main(/*0*/ aNotNullNotNullNotNull: Test<Derived!, Derived!, Derived!>!, /*1*/ aNotNullNotNullNull: Test<Derived!, Derived!, @org.jspecify.nullness.Nullable Derived!>!, /*2*/ aNotNullNullNotNull: Test<Derived!, @org.jspecify.nullness.Nullable Derived!, Derived!>!, /*3*/ aNotNullNullNull: Test<Derived!, @org.jspecify.nullness.Nullable Derived!, @org.jspecify.nullness.Nullable Derived!>!, /*4*/ aObjectNotNullNotNullNotNull: Test<kotlin.Any!, kotlin.Any!, kotlin.Any!>!, /*5*/ aObjectNotNullNotNullNull: Test<kotlin.Any!, kotlin.Any!, @org.jspecify.nullness.Nullable kotlin.Any!>!, /*6*/ aObjectNotNullNullNotNull: Test<kotlin.Any!, @org.jspecify.nullness.Nullable kotlin.Any!, kotlin.Any!>!, /*7*/ aObjectNotNullNullNull: Test<kotlin.Any!, @org.jspecify.nullness.Nullable kotlin.Any!, @org.jspecify.nullness.Nullable kotlin.Any!>!, /*8*/ b: AnnotatedBoundsOfWildcard!): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/AnnotatedBoundsOfWildcard.kt

@@ -1,5 +1,35 @@
-// JAVA_SOURCES: AnnotatedBoundsOfWildcard.java
+// WITH_FOREIGN_ANNOTATIONS
 
+// FILE: AnnotatedBoundsOfWildcard.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class AnnotatedBoundsOfWildcard {
+    public void superAsIs(Test<? super Base, ? super @Nullable Base, ? super @NullnessUnspecified Base> a) {}
+    public void superNotNull(Test<? super Base, ? super Base, ? super Base> a) {}
+    public void superNullable(Test<? super @Nullable Base, ? super @Nullable Base, ? super @Nullable Base> a) {}
+
+    public void extendsAsIs(Test<? extends Base, ? extends @Nullable Base, ? extends @NullnessUnspecified Base> a) {}
+    public void extendsNotNull(Test<? extends Base, ? extends Base, ? extends Base> a) {}
+    public void extendsNullable(Test<? extends @Nullable Base, ? extends @Nullable Base, ? extends @Nullable Base> a) {}
+
+    public void noBounds(Test<? extends @NullnessUnspecified Object, ? extends @NullnessUnspecified Object, ? extends @NullnessUnspecified Object> a) {}
+}
+
+// FILE: Base.java
+public class Base {}
+
+// FILE: Derived.java
+public class Derived extends Base {}
+
+// FILE: Test.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Test<T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> { }
+
+// FILE: main.kt
 fun main(
             aNotNullNotNullNotNull: Test<Derived, Derived, Derived>,
             aNotNullNotNullNull: Test<Derived, Derived, Derived?>,

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/AnnotatedBoundsOfWildcard.txt

@@ -5,12 +5,12 @@ public fun main(/*0*/ aNotNullNotNullNotNull: Test<Derived, Derived, Derived>, /
 @org.jspecify.nullness.NullMarked public open class AnnotatedBoundsOfWildcard {
     public constructor AnnotatedBoundsOfWildcard()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open fun extendsAsIs(/*0*/ a: Test<out @org.jspecify.nullness.NullnessUnspecified Base!, out @org.jspecify.nullness.NullnessUnspecified Base!, out @org.jspecify.nullness.NullnessUnspecified Base!>!): kotlin.Unit
+    public open fun extendsAsIs(/*0*/ a: Test<out Base!, out @org.jspecify.nullness.Nullable Base!, out @org.jspecify.nullness.NullnessUnspecified Base!>!): kotlin.Unit
     public open fun extendsNotNull(/*0*/ a: Test<out Base!, out Base!, out Base!>!): kotlin.Unit
     public open fun extendsNullable(/*0*/ a: Test<out @org.jspecify.nullness.Nullable Base!, out @org.jspecify.nullness.Nullable Base!, out @org.jspecify.nullness.Nullable Base!>!): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open fun noBounds(/*0*/ a: Test<*, *, *>!): kotlin.Unit
-    public open fun superAsIs(/*0*/ a: Test<in @org.jspecify.nullness.NullnessUnspecified Base!, in @org.jspecify.nullness.NullnessUnspecified Base!, in @org.jspecify.nullness.NullnessUnspecified Base!>!): kotlin.Unit
+    public open fun noBounds(/*0*/ a: Test<out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!, out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!, out @org.jspecify.nullness.NullnessUnspecified kotlin.Any!>!): kotlin.Unit
+    public open fun superAsIs(/*0*/ a: Test<in Base!, in @org.jspecify.nullness.Nullable Base!, in @org.jspecify.nullness.NullnessUnspecified Base!>!): kotlin.Unit
     public open fun superNotNull(/*0*/ a: Test<in Base!, in Base!, in Base!>!): kotlin.Unit
     public open fun superNullable(/*0*/ a: Test<in @org.jspecify.nullness.Nullable Base!, in @org.jspecify.nullness.Nullable Base!, in @org.jspecify.nullness.Nullable Base!>!): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
@@ -37,10 +37,3 @@ public open class Derived : Base {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-@org.jspecify.nullness.NullMarked public open class Use {
-    public constructor Use()
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open fun main(/*0*/ aNotNullNotNullNotNull: Test<Derived!, Derived!, Derived!>!, /*1*/ aNotNullNotNullNull: Test<Derived!, Derived!, @org.jspecify.nullness.Nullable Derived!>!, /*2*/ aNotNullNullNotNull: Test<Derived!, @org.jspecify.nullness.Nullable Derived!, Derived!>!, /*3*/ aNotNullNullNull: Test<Derived!, @org.jspecify.nullness.Nullable Derived!, @org.jspecify.nullness.Nullable Derived!>!, /*4*/ aObjectNotNullNotNullNotNull: Test<kotlin.Any!, kotlin.Any!, kotlin.Any!>!, /*5*/ aObjectNotNullNotNullNull: Test<kotlin.Any!, kotlin.Any!, @org.jspecify.nullness.Nullable kotlin.Any!>!, /*6*/ aObjectNotNullNullNotNull: Test<kotlin.Any!, @org.jspecify.nullness.Nullable kotlin.Any!, kotlin.Any!>!, /*7*/ aObjectNotNullNullNull: Test<kotlin.Any!, @org.jspecify.nullness.Nullable kotlin.Any!, @org.jspecify.nullness.Nullable kotlin.Any!>!, /*8*/ b: AnnotatedBoundsOfWildcard!): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/Defaults.fir.kt

@@ -1,17 +1,44 @@
-// JAVA_SOURCES: Defaults.java
-// JSPECIFY_STATE warn
+// WITH_FOREIGN_ANNOTATIONS
 
+// FILE: Defaults.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Defaults {
+    public Foo defaultField = null;
+    @Nullable public Foo field = null;
+
+    public Foo everythingNotNullable(Foo x) { return null; }
+
+    public @Nullable Foo everythingNullable(@Nullable Foo x) { return null; }
+
+    public @NullnessUnspecified Foo everythingUnknown(@NullnessUnspecified Foo x) { return null; }
+
+    public @Nullable Foo mixed(Foo x) { return null; }
+
+    public Foo explicitlyNullnessUnspecified(@NullnessUnspecified Foo x) { return null; }
+}
+
+// FILE: Foo.java
+public class Foo {
+    public Object foo() { return null; }
+}
+
+// FILE: main.kt
 fun main(a: Defaults, x: Foo): Unit {
     // jspecify_nullness_mismatch
     a.everythingNotNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>).foo()
     a.everythingNotNullable(x).foo()
 
+    // jspecify_nullness_mismatch
     <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.everythingNullable(null)<!>.foo()
 
     a.everythingUnknown(null).foo()
 
     // jspecify_nullness_mismatch
     <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.mixed(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>)<!>.foo()
+    // jspecify_nullness_mismatch
     <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.mixed(x)<!>.foo()
 
     a.explicitlyNullnessUnspecified(x).foo()
@@ -19,5 +46,6 @@ fun main(a: Defaults, x: Foo): Unit {
 
     a.defaultField.foo()
 
+    // jspecify_nullness_mismatch
     <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.field<!>.foo()
-}
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/Defaults.fir.txt

@@ -23,13 +23,3 @@ public open class Foo {
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
-
-public open class Use {
-    public constructor Use()
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-
-    // Static members
-    public/*package*/ open fun main(/*0*/ a: Defaults!, /*1*/ x: Foo!): kotlin.Unit
-}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/Defaults.kt

@@ -1,16 +1,44 @@
-// JAVA_SOURCES: Defaults.java
+// WITH_FOREIGN_ANNOTATIONS
 
+// FILE: Defaults.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Defaults {
+    public Foo defaultField = null;
+    @Nullable public Foo field = null;
+
+    public Foo everythingNotNullable(Foo x) { return null; }
+
+    public @Nullable Foo everythingNullable(@Nullable Foo x) { return null; }
+
+    public @NullnessUnspecified Foo everythingUnknown(@NullnessUnspecified Foo x) { return null; }
+
+    public @Nullable Foo mixed(Foo x) { return null; }
+
+    public Foo explicitlyNullnessUnspecified(@NullnessUnspecified Foo x) { return null; }
+}
+
+// FILE: Foo.java
+public class Foo {
+    public Object foo() { return null; }
+}
+
+// FILE: main.kt
 fun main(a: Defaults, x: Foo): Unit {
     // jspecify_nullness_mismatch
     a.everythingNotNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>).foo()
     a.everythingNotNullable(x).foo()
 
+    // jspecify_nullness_mismatch
     <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.everythingNullable(null)<!>.foo()
 
     a.everythingUnknown(null).foo()
 
     // jspecify_nullness_mismatch
     <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.mixed(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>)<!>.foo()
+    // jspecify_nullness_mismatch
     <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.mixed(x)<!>.foo()
 
     a.explicitlyNullnessUnspecified(x).foo()
@@ -18,5 +46,6 @@ fun main(a: Defaults, x: Foo): Unit {
 
     a.defaultField.foo()
 
+    // jspecify_nullness_mismatch
     <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.field<!>.foo()
 }

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/Defaults.txt

@@ -24,12 +24,3 @@ public open class Foo {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-public open class Use {
-    public constructor Use()
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-
-    // Static members
-    public/*package*/ open fun main(/*0*/ a: Defaults!, /*1*/ x: Foo!): kotlin.Unit
-}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/IgnoreAnnotations.fir.kt

@@ -0,0 +1,49 @@
+// WITH_FOREIGN_ANNOTATIONS
+
+// FILE: IgnoreAnnotations.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class IgnoreAnnotations {
+    @Nullable public Derived field = null;
+
+    @Nullable
+    public Derived foo(Derived x, @NullnessUnspecified Base y) {
+        return null;
+    }
+
+    public Derived everythingNotNullable(Derived x) { return null; }
+
+    public @Nullable Derived everythingNullable(@Nullable Derived x) { return null; }
+
+    public @NullnessUnspecified Derived everythingUnknown(@NullnessUnspecified Derived x) { return null; }
+}
+
+// FILE: Base.java
+public class Base {
+    void foo() {}
+}
+
+// FILE: Derived.java
+public class Derived extends Base { }
+
+// FILE: main.kt
+fun main(a: IgnoreAnnotations, x: Derived): Unit {
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(x, null)<!>.foo()
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, x)<!>.foo()
+
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.field<!>.foo()
+
+    // jspecify_nullness_mismatch
+    a.everythingNotNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.everythingNullable(null)<!>.foo()
+
+    a.everythingUnknown(null).foo()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/IgnoreAnnotations.fir.txt

@@ -29,13 +29,3 @@ public open class Derived : Base {
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
-
-public open class Use {
-    public constructor Use()
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-
-    // Static members
-    public/*package*/ open fun main(/*0*/ a: IgnoreAnnotations!, /*1*/ x: Derived!): kotlin.Unit
-}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/IgnoreAnnotations.kt

@@ -0,0 +1,49 @@
+// WITH_FOREIGN_ANNOTATIONS
+
+// FILE: IgnoreAnnotations.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class IgnoreAnnotations {
+    @Nullable public Derived field = null;
+
+    @Nullable
+    public Derived foo(Derived x, @NullnessUnspecified Base y) {
+        return null;
+    }
+
+    public Derived everythingNotNullable(Derived x) { return null; }
+
+    public @Nullable Derived everythingNullable(@Nullable Derived x) { return null; }
+
+    public @NullnessUnspecified Derived everythingUnknown(@NullnessUnspecified Derived x) { return null; }
+}
+
+// FILE: Base.java
+public class Base {
+    void foo() {}
+}
+
+// FILE: Derived.java
+public class Derived extends Base { }
+
+// FILE: main.kt
+fun main(a: IgnoreAnnotations, x: Derived): Unit {
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(x, null)<!>.foo()
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, x)<!>.foo()
+
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.field<!>.foo()
+
+    // jspecify_nullness_mismatch
+    a.everythingNotNullable(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>).foo()
+    a.everythingNotNullable(x).foo()
+
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.everythingNullable(null)<!>.foo()
+
+    a.everythingUnknown(null).foo()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/IgnoreAnnotations.txt

@@ -30,12 +30,3 @@ public open class Derived : Base {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-public open class Use {
-    public constructor Use()
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-
-    // Static members
-    public/*package*/ open fun main(/*0*/ a: IgnoreAnnotations!, /*1*/ x: Derived!): kotlin.Unit
-}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NonPlatformTypeParameter.fir.kt

@@ -0,0 +1,30 @@
+// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// WITH_FOREIGN_ANNOTATIONS
+
+// FILE: NonPlatformTypeParameter.java
+
+import org.jspecify.nullness.*;
+
+public class NonPlatformTypeParameter<T extends @Nullable Object> {
+    public void foo(T t) {}
+    public <E extends @Nullable Object> void bar(E e) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+fun <T : Test> main(a1: NonPlatformTypeParameter<Any?>, a2: NonPlatformTypeParameter<Test>, x: T): Unit {
+    a1.foo(null)
+    a1.bar<Test?>(null)
+    // jspecify_nullness_mismatch
+    a1.bar<T>(null)
+    a1.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    a2.foo(null)
+    a2.bar<Test?>(null)
+    // jspecify_nullness_mismatch
+    a2.bar<T>(null)
+    a2.bar<T>(x)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NonPlatformTypeParameter.fir.txt

@@ -17,11 +17,3 @@ public open class Test {
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
-
-@org.jspecify.nullness.NullMarked public open class Use {
-    public constructor Use()
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open fun </*0*/ T : Test!> main(/*0*/ a1: NonPlatformTypeParameter<@org.jspecify.nullness.Nullable kotlin.Any!>!, /*1*/ a2: NonPlatformTypeParameter<Test!>!, /*2*/ x: T!): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NonPlatformTypeParameter.kt

@@ -0,0 +1,30 @@
+// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated
+// WITH_FOREIGN_ANNOTATIONS
+
+// FILE: NonPlatformTypeParameter.java
+
+import org.jspecify.nullness.*;
+
+public class NonPlatformTypeParameter<T extends @Nullable Object> {
+    public void foo(T t) {}
+    public <E extends @Nullable Object> void bar(E e) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+fun <T : Test> main(a1: NonPlatformTypeParameter<Any?>, a2: NonPlatformTypeParameter<Test>, x: T): Unit {
+    a1.foo(null)
+    a1.bar<Test?>(null)
+    // jspecify_nullness_mismatch
+    a1.bar<T>(null)
+    a1.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    a2.foo(null)
+    a2.bar<Test?>(null)
+    // jspecify_nullness_mismatch
+    a2.bar<T>(null)
+    a2.bar<T>(x)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NonPlatformTypeParameter.txt

@@ -18,10 +18,3 @@ public open class Test {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-@org.jspecify.nullness.NullMarked public open class Use {
-    public constructor Use()
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open fun </*0*/ T : Test!> main(/*0*/ a1: NonPlatformTypeParameter<@org.jspecify.nullness.Nullable kotlin.Any!>!, /*1*/ a2: NonPlatformTypeParameter<Test!>!, /*2*/ x: T!): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NullnessUnspecifiedTypeParameter.fir.kt

@@ -0,0 +1,39 @@
+// WITH_FOREIGN_ANNOTATIONS
+
+// FILE: NullnessUnspecifiedTypeParameter.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class NullnessUnspecifiedTypeParameter<T> {
+    public void foo(T t) {}
+
+    public void bar(Test s, T t) {} // t should not become not nullable
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+// jspecify_nullness_mismatch
+fun main(a1: NullnessUnspecifiedTypeParameter<Any>, a2: NullnessUnspecifiedTypeParameter<<!UPPER_BOUND_VIOLATED_BASED_ON_JAVA_ANNOTATIONS!>Any?<!>>, x: Test): Unit {
+    // jspecify_nullness_mismatch
+    a1.foo(null)
+    a1.foo(1)
+
+    // jspecify_nullness_mismatch
+    a2.foo(null)
+    a2.foo(1)
+
+    // jspecify_nullness_mismatch
+    a1.bar(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, null)
+    // jspecify_nullness_mismatch
+    a1.bar(x, null)
+    a1.bar(x, 1)
+
+    // jspecify_nullness_mismatch
+    a2.bar(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, null)
+    // jspecify_nullness_mismatch
+    a2.bar(x, null)
+    a2.bar(x, 1)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NullnessUnspecifiedTypeParameter.fir.txt

@@ -17,11 +17,3 @@ public open class Test {
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
-
-public open class Use {
-    public constructor Use()
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public/*package*/ open fun main(/*0*/ a1: NullnessUnspecifiedTypeParameter<kotlin.Any!>!, /*1*/ a2: NullnessUnspecifiedTypeParameter<@org.jspecify.nullness.Nullable kotlin.Any!>!, /*2*/ x: Test!): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NullnessUnspecifiedTypeParameter.kt

@@ -0,0 +1,39 @@
+// WITH_FOREIGN_ANNOTATIONS
+
+// FILE: NullnessUnspecifiedTypeParameter.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class NullnessUnspecifiedTypeParameter<T> {
+    public void foo(T t) {}
+
+    public void bar(Test s, T t) {} // t should not become not nullable
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+// jspecify_nullness_mismatch
+fun main(a1: NullnessUnspecifiedTypeParameter<Any>, a2: NullnessUnspecifiedTypeParameter<<!UPPER_BOUND_VIOLATED_BASED_ON_JAVA_ANNOTATIONS!>Any?<!>>, x: Test): Unit {
+    // jspecify_nullness_mismatch
+    a1.foo(null)
+    a1.foo(1)
+
+    // jspecify_nullness_mismatch
+    a2.foo(null)
+    a2.foo(1)
+
+    // jspecify_nullness_mismatch
+    a1.bar(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, null)
+    // jspecify_nullness_mismatch
+    a1.bar(x, null)
+    a1.bar(x, 1)
+
+    // jspecify_nullness_mismatch
+    a2.bar(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, null)
+    // jspecify_nullness_mismatch
+    a2.bar(x, null)
+    a2.bar(x, 1)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/NullnessUnspecifiedTypeParameter.txt

@@ -18,10 +18,3 @@ public open class Test {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-public open class Use {
-    public constructor Use()
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public/*package*/ open fun main(/*0*/ a1: NullnessUnspecifiedTypeParameter<kotlin.Any!>!, /*1*/ a2: NullnessUnspecifiedTypeParameter<@org.jspecify.nullness.Nullable kotlin.Any!>!, /*2*/ x: Test!): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/SelfType.fir.kt

@@ -0,0 +1,58 @@
+// WITH_FOREIGN_ANNOTATIONS
+
+// FILE: SelfType.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class SelfType<T extends SelfType<T>> {
+    public void foo(T t) {}
+}
+
+// FILE: B.java
+public class B extends SelfType<B> {}
+
+// FILE: C.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class C<E extends C<E>> extends SelfType<E> {}
+
+// FILE: AK.java
+public class AK extends SelfType<AK> {}
+
+// FILE: AKN.java
+import org.jspecify.nullness.*;
+
+public class AKN extends SelfType<@Nullable AK> {}
+
+// FILE: BK.java
+public class BK extends B {}
+
+// FILE: CK.java
+public class CK extends C<CK> {}
+
+// FILE: CKN.java
+import org.jspecify.nullness.*;
+
+public class CKN extends C<@Nullable CK> {}
+
+// FILE: main.kt
+fun main(ak: AK, akn: AKN, bk: BK, ck: CK, ckn: CKN): Unit {
+    ak.foo(ak)
+    // jspecify_nullness_mismatch
+    ak.foo(null)
+
+    // jspecify_nullness_mismatch
+    akn.foo(null)
+
+    bk.foo(bk)
+    // jspecify_nullness_mismatch
+    bk.foo(null)
+
+    ck.foo(ck)
+    // jspecify_nullness_mismatch
+    ck.foo(null)
+
+    // jspecify_nullness_mismatch
+    ckn.foo(null)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/SelfType.fir.txt

@@ -34,7 +34,7 @@ public open class BK : B {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-public open class C</*0*/ E : C<E!>!> : SelfType<E!> {
+@org.jspecify.nullness.NullMarked public open class C</*0*/ E : C<E!>!> : SelfType<E!> {
     public constructor C</*0*/ E : C<E!>!>()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: E!): kotlin.Unit
@@ -55,11 +55,10 @@ public open class CKN : C<@org.jspecify.nullness.Nullable CK!> {
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: @org.jspecify.nullness.Nullable CK!): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open fun main(/*0*/ ak: AK!, /*1*/ akn: AKN!, /*2*/ bk: BK!, /*3*/ ck: CK!, /*4*/ ckn: CKN!): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-public open class SelfType</*0*/ T : SelfType<T!>!> {
+@org.jspecify.nullness.NullMarked public open class SelfType</*0*/ T : SelfType<T!>!> {
     public constructor SelfType</*0*/ T : SelfType<T!>!>()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open fun foo(/*0*/ t: T!): kotlin.Unit

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/SelfType.kt

@@ -0,0 +1,58 @@
+// WITH_FOREIGN_ANNOTATIONS
+
+// FILE: SelfType.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class SelfType<T extends SelfType<T>> {
+    public void foo(T t) {}
+}
+
+// FILE: B.java
+public class B extends SelfType<B> {}
+
+// FILE: C.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class C<E extends C<E>> extends SelfType<E> {}
+
+// FILE: AK.java
+public class AK extends SelfType<AK> {}
+
+// FILE: AKN.java
+import org.jspecify.nullness.*;
+
+public class AKN extends SelfType<@Nullable AK> {}
+
+// FILE: BK.java
+public class BK extends B {}
+
+// FILE: CK.java
+public class CK extends C<CK> {}
+
+// FILE: CKN.java
+import org.jspecify.nullness.*;
+
+public class CKN extends C<@Nullable CK> {}
+
+// FILE: main.kt
+fun main(ak: AK, akn: AKN, bk: BK, ck: CK, ckn: CKN): Unit {
+    ak.foo(ak)
+    // jspecify_nullness_mismatch
+    ak.foo(null)
+
+    // jspecify_nullness_mismatch
+    akn.foo(null)
+
+    bk.foo(bk)
+    // jspecify_nullness_mismatch
+    bk.foo(null)
+
+    ck.foo(ck)
+    // jspecify_nullness_mismatch
+    ck.foo(null)
+
+    // jspecify_nullness_mismatch
+    ckn.foo(null)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/SelfType.txt

@@ -34,7 +34,7 @@ public open class BK : B {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-public open class C</*0*/ E : C<E!>!> : SelfType<E!> {
+@org.jspecify.nullness.NullMarked public open class C</*0*/ E : C<E!>!> : SelfType<E!> {
     public constructor C</*0*/ E : C<E!>!>()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: E!): kotlin.Unit
@@ -55,14 +55,14 @@ public open class CKN : C<@org.jspecify.nullness.Nullable CK!> {
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: @org.jspecify.nullness.Nullable CK!): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open fun main(/*0*/ ak: AK!, /*1*/ akn: AKN!, /*2*/ bk: BK!, /*3*/ ck: CK!, /*4*/ ckn: CKN!): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-public open class SelfType</*0*/ T : SelfType<T!>!> {
+@org.jspecify.nullness.NullMarked public open class SelfType</*0*/ T : SelfType<T!>!> {
     public constructor SelfType</*0*/ T : SelfType<T!>!>()
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open fun foo(/*0*/ t: T!): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
+

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/Simple.fir.kt

@@ -0,0 +1,40 @@
+// WITH_FOREIGN_ANNOTATIONS
+
+// FILE: Simple.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Simple {
+    @Nullable public Derived field = null;
+
+    @Nullable
+    public Derived foo(Derived x, @NullnessUnspecified Base y) {
+        return null;
+    }
+
+    public Derived bar() {
+        return null;
+    }
+}
+
+// FILE: Base.java
+public class Base {}
+
+// FILE: Derived.java
+public class Derived extends Base {
+    void foo() {}
+}
+
+// FILE: main.kt
+fun main(a: Simple, x: Derived): Unit {
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(x, null)<!>.foo()
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, x)<!>.foo()
+
+    a.bar().foo()
+
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.field<!>.foo()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/Simple.fir.txt

@@ -26,13 +26,3 @@ public open class Derived : Base {
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
-
-@org.jspecify.nullness.NullMarked public open class Use {
-    public constructor Use()
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-
-    // Static members
-    public open fun main(/*0*/ a: Simple!, /*1*/ x: Derived!): kotlin.Unit
-}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/Simple.kt

@@ -0,0 +1,40 @@
+// WITH_FOREIGN_ANNOTATIONS
+
+// FILE: Simple.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class Simple {
+    @Nullable public Derived field = null;
+
+    @Nullable
+    public Derived foo(Derived x, @NullnessUnspecified Base y) {
+        return null;
+    }
+
+    public Derived bar() {
+        return null;
+    }
+}
+
+// FILE: Base.java
+public class Base {}
+
+// FILE: Derived.java
+public class Derived extends Base {
+    void foo() {}
+}
+
+// FILE: main.kt
+fun main(a: Simple, x: Derived): Unit {
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(x, null)<!>.foo()
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.foo(<!NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>null<!>, x)<!>.foo()
+
+    a.bar().foo()
+
+    // jspecify_nullness_mismatch
+    <!RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS!>a.field<!>.foo()
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/Simple.txt

@@ -27,12 +27,3 @@ public open class Derived : Base {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-@org.jspecify.nullness.NullMarked public open class Use {
-    public constructor Use()
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-
-    // Static members
-    public open fun main(/*0*/ a: Simple!, /*1*/ x: Derived!): kotlin.Unit
-}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/TypeArgumentsFromParameterBounds.fir.kt

@@ -0,0 +1,49 @@
+// WITH_FOREIGN_ANNOTATIONS
+
+// FILE: TypeArgumentsFromParameterBounds.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class TypeArgumentsFromParameterBounds<T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> {}
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class A {
+    public void bar(TypeArgumentsFromParameterBounds<Test, Test, Test> a) {}
+}
+
+// FILE: B.java
+import org.jspecify.nullness.*;
+
+public class B {
+    public void bar(TypeArgumentsFromParameterBounds<Test, Test, Test> a) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+fun main(
+    aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test, Test, Test>,
+    aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test, Test, Test?>,
+    aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test, Test?, Test>,
+    aNotNullNullNull: TypeArgumentsFromParameterBounds<Test, Test?, Test?>,
+    a: A, b: B
+): Unit {
+    a.bar(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    a.bar(aNotNullNotNullNull)
+    // jspecify_nullness_mismatch
+    a.bar(aNotNullNullNotNull)
+    // jspecify_nullness_mismatch
+    a.bar(aNotNullNullNull)
+
+    // jspecify_nullness_mismatch
+    b.bar(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.bar(aNotNullNotNullNull)
+    b.bar(aNotNullNullNotNull)
+    b.bar(aNotNullNullNull)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/TypeArgumentsFromParameterBounds.fir.txt

@@ -1,25 +1,17 @@
 package
 
-public fun main(/*0*/ aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test, Test, Test>, /*1*/ aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test, Test, Test?>, /*2*/ aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test, Test?, Test>, /*3*/ aNotNullNullNull: TypeArgumentsFromParameterBounds<Test, Test?, Test?>, /*4*/ a: A, /*5*/ b: B, /*6*/ c: C): kotlin.Unit
+public fun main(/*0*/ aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test, Test, Test>, /*1*/ aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test, Test, Test?>, /*2*/ aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test, Test?, Test>, /*3*/ aNotNullNullNull: TypeArgumentsFromParameterBounds<Test, Test?, Test?>, /*4*/ a: A, /*5*/ b: B): kotlin.Unit
 
-public open class A {
+@org.jspecify.nullness.NullMarked public open class A {
     public constructor A()
-    public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<@org.jspecify.nullness.Nullable Test!, @org.jspecify.nullness.Nullable Test!, @org.jspecify.nullness.Nullable Test!>!): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-}
-
-@org.jspecify.nullness.NullMarked public open class B {
-    public constructor B()
     public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<Test!, Test!, Test!>!): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-public open class C {
-    public constructor C()
+public open class B {
+    public constructor B()
     public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<Test!, Test!, Test!>!): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
@@ -39,13 +31,3 @@ public open class Test {
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
-
-@org.jspecify.nullness.NullMarked public open class Use {
-    public constructor Use()
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-
-    // Static members
-    public open fun main(/*0*/ aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test!, Test!, Test!>!, /*1*/ aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test!, Test!, @org.jspecify.nullness.Nullable Test!>!, /*2*/ aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test!, @org.jspecify.nullness.Nullable Test!, Test!>!, /*3*/ aNotNullNullNull: TypeArgumentsFromParameterBounds<Test!, @org.jspecify.nullness.Nullable Test!, @org.jspecify.nullness.Nullable Test!>!, /*4*/ a: A!, /*5*/ b: B!, /*6*/ c: C!): kotlin.Unit
-}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/TypeArgumentsFromParameterBounds.kt

@@ -0,0 +1,49 @@
+// WITH_FOREIGN_ANNOTATIONS
+
+// FILE: TypeArgumentsFromParameterBounds.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class TypeArgumentsFromParameterBounds<T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> {}
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class A {
+    public void bar(TypeArgumentsFromParameterBounds<Test, Test, Test> a) {}
+}
+
+// FILE: B.java
+import org.jspecify.nullness.*;
+
+public class B {
+    public void bar(TypeArgumentsFromParameterBounds<Test, Test, Test> a) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+fun main(
+    aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test, Test, Test>,
+    aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test, Test, Test?>,
+    aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test, Test?, Test>,
+    aNotNullNullNull: TypeArgumentsFromParameterBounds<Test, Test?, Test?>,
+    a: A, b: B
+): Unit {
+    a.bar(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    a.bar(aNotNullNotNullNull)
+    // jspecify_nullness_mismatch
+    a.bar(aNotNullNullNotNull)
+    // jspecify_nullness_mismatch
+    a.bar(aNotNullNullNull)
+
+    // jspecify_nullness_mismatch
+    b.bar(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
+    b.bar(aNotNullNotNullNull)
+    b.bar(aNotNullNullNotNull)
+    b.bar(aNotNullNullNull)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/TypeArgumentsFromParameterBounds.txt

@@ -1,25 +1,17 @@
 package
 
-public fun main(/*0*/ aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test, Test, Test>, /*1*/ aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test, Test, Test?>, /*2*/ aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test, Test?, Test>, /*3*/ aNotNullNullNull: TypeArgumentsFromParameterBounds<Test, Test?, Test?>, /*4*/ a: A, /*5*/ b: B, /*6*/ c: C): kotlin.Unit
+public fun main(/*0*/ aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test, Test, Test>, /*1*/ aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test, Test, Test?>, /*2*/ aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test, Test?, Test>, /*3*/ aNotNullNullNull: TypeArgumentsFromParameterBounds<Test, Test?, Test?>, /*4*/ a: A, /*5*/ b: B): kotlin.Unit
 
-public open class A {
+@org.jspecify.nullness.NullMarked public open class A {
     public constructor A()
-    public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<@org.jspecify.nullness.Nullable Test!, @org.jspecify.nullness.Nullable Test!, @org.jspecify.nullness.Nullable Test!>!): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-}
-
-@org.jspecify.nullness.NullMarked public open class B {
-    public constructor B()
     public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<Test!, Test!, Test!>!): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-public open class C {
-    public constructor C()
+public open class B {
+    public constructor B()
     public open fun bar(/*0*/ a: TypeArgumentsFromParameterBounds<Test!, Test!, Test!>!): kotlin.Unit
     public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
@@ -40,12 +32,3 @@ public open class Test {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-@org.jspecify.nullness.NullMarked public open class Use {
-    public constructor Use()
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-
-    // Static members
-    public open fun main(/*0*/ aNotNullNotNullNotNull: TypeArgumentsFromParameterBounds<Test!, Test!, Test!>!, /*1*/ aNotNullNotNullNull: TypeArgumentsFromParameterBounds<Test!, Test!, @org.jspecify.nullness.Nullable Test!>!, /*2*/ aNotNullNullNotNull: TypeArgumentsFromParameterBounds<Test!, @org.jspecify.nullness.Nullable Test!, Test!>!, /*3*/ aNotNullNullNull: TypeArgumentsFromParameterBounds<Test!, @org.jspecify.nullness.Nullable Test!, @org.jspecify.nullness.Nullable Test!>!, /*4*/ a: A!, /*5*/ b: B!, /*6*/ c: C!): kotlin.Unit
-}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/TypeParameterBounds.fir.kt

@@ -0,0 +1,47 @@
+// WITH_FOREIGN_ANNOTATIONS
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class A<T> {
+    public void foo(@NullnessUnspecified T t) {}
+    public <E> void bar(E e) {}
+}
+
+// FILE: B.java
+import org.jspecify.nullness.*;
+@NullMarked
+public class B<T> {
+    public void foo(T t) {}
+    public <E> void bar(E e) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+// jspecify_nullness_mismatch
+fun <T : Test> main(a1: A<<!UPPER_BOUND_VIOLATED_BASED_ON_JAVA_ANNOTATIONS!>Any?<!>>, a2: A<Test>, b1: B<<!UPPER_BOUND_VIOLATED_BASED_ON_JAVA_ANNOTATIONS!>Any?<!>>, b2: B<Test>, x: T): Unit {
+    a1.foo(null)
+    // jspecify_nullness_mismatch
+    a1.bar<T?>(null)
+    a1.bar<T>(x)
+
+    a2.foo(null)
+    // jspecify_nullness_mismatch
+    a2.bar<T?>(null)
+    a2.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    b1.foo(null)
+    // jspecify_nullness_mismatch
+    b1.bar<T?>(null)
+    b1.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    b2.foo(null)
+    // jspecify_nullness_mismatch
+    b2.bar<T?>(null)
+    b2.bar<T>(x)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/TypeParameterBounds.fir.txt

@@ -26,11 +26,3 @@ public open class Test {
     public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
-
-@org.jspecify.nullness.NullMarked public open class TypeParameterBounds {
-    public constructor TypeParameterBounds()
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public/*package*/ open fun </*0*/ T : Test!> main(/*0*/ a1: A<@org.jspecify.nullness.Nullable kotlin.Any!>!, /*1*/ a2: A<Test!>!, /*2*/ b1: B<@org.jspecify.nullness.Nullable kotlin.Any!>!, /*3*/ b2: B<Test!>!, /*4*/ x: T!): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/TypeParameterBounds.kt

@@ -0,0 +1,47 @@
+// WITH_FOREIGN_ANNOTATIONS
+
+// FILE: A.java
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class A<T> {
+    public void foo(@NullnessUnspecified T t) {}
+    public <E> void bar(E e) {}
+}
+
+// FILE: B.java
+import org.jspecify.nullness.*;
+@NullMarked
+public class B<T> {
+    public void foo(T t) {}
+    public <E> void bar(E e) {}
+}
+
+// FILE: Test.java
+public class Test {}
+
+// FILE: main.kt
+// jspecify_nullness_mismatch
+fun <T : Test> main(a1: A<<!UPPER_BOUND_VIOLATED_BASED_ON_JAVA_ANNOTATIONS!>Any?<!>>, a2: A<Test>, b1: B<<!UPPER_BOUND_VIOLATED_BASED_ON_JAVA_ANNOTATIONS!>Any?<!>>, b2: B<Test>, x: T): Unit {
+    a1.foo(null)
+    // jspecify_nullness_mismatch
+    a1.bar<T?>(null)
+    a1.bar<T>(x)
+
+    a2.foo(null)
+    // jspecify_nullness_mismatch
+    a2.bar<T?>(null)
+    a2.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    b1.foo(null)
+    // jspecify_nullness_mismatch
+    b1.bar<T?>(null)
+    b1.bar<T>(x)
+
+    // jspecify_nullness_mismatch
+    b2.foo(null)
+    // jspecify_nullness_mismatch
+    b2.bar<T?>(null)
+    b2.bar<T>(x)
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/TypeParameterBounds.txt

@@ -27,10 +27,3 @@ public open class Test {
     public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
 }
 
-@org.jspecify.nullness.NullMarked public open class TypeParameterBounds {
-    public constructor TypeParameterBounds()
-    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
-    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
-    public/*package*/ open fun </*0*/ T : Test!> main(/*0*/ a1: A<@org.jspecify.nullness.Nullable kotlin.Any!>!, /*1*/ a2: A<Test!>!, /*2*/ b1: B<@org.jspecify.nullness.Nullable kotlin.Any!>!, /*3*/ b2: B<Test!>!, /*4*/ x: T!): kotlin.Unit
-    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
-}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/WildcardsWithDefault.fir.kt

@@ -1,5 +1,19 @@
-// JAVA_SOURCES: WildcardsWithDefault.java
+// WITH_FOREIGN_ANNOTATIONS
 
+// FILE: WildcardsWithDefault.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class WildcardsWithDefault {
+    public void noBoundsNotNull(A<?, ?, ?> a) {}
+    public void noBoundsNullable(A<? extends @Nullable Object, ? extends @Nullable Object, ? extends @Nullable Object> a) {}
+}
+
+// FILE: A.java
+public class A <T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> {}
+
+// FILE: main.kt
 fun main(
             aNotNullNotNullNotNull: A<Any, Any, Any>,
             aNotNullNotNullNull: A<Any, Any, Any?>,
@@ -7,8 +21,8 @@ fun main(
             aNotNullNullNull: A<Any, Any?, Any?>,
             b: WildcardsWithDefault
 ): Unit {
-    // jspecify_nullness_mismatch
     b.noBoundsNotNull(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
     b.noBoundsNotNull(aNotNullNotNullNull)
     // jspecify_nullness_mismatch
     b.noBoundsNotNull(aNotNullNullNotNull)

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/WildcardsWithDefault.fir.txt

@@ -0,0 +1,19 @@
+package
+
+public fun main(/*0*/ aNotNullNotNullNotNull: A<kotlin.Any, kotlin.Any, kotlin.Any>, /*1*/ aNotNullNotNullNull: A<kotlin.Any, kotlin.Any, kotlin.Any?>, /*2*/ aNotNullNullNotNull: A<kotlin.Any, kotlin.Any?, kotlin.Any>, /*3*/ aNotNullNullNull: A<kotlin.Any, kotlin.Any?, kotlin.Any?>, /*4*/ b: WildcardsWithDefault): kotlin.Unit
+
+public open class A</*0*/ T : kotlin.Any!, /*1*/ E : @Nullable /* annotation class not found */ kotlin.Any!, /*2*/ F : @NullnessUnspecified /* annotation class not found */ kotlin.Any!> {
+    public constructor A</*0*/ T : kotlin.Any!, /*1*/ E : @Nullable /* annotation class not found */ kotlin.Any!, /*2*/ F : @NullnessUnspecified /* annotation class not found */ kotlin.Any!>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@org.jspecify.nullness.NullMarked public open class WildcardsWithDefault {
+    public constructor WildcardsWithDefault()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open fun noBoundsNotNull(/*0*/ a: A<*, *, *>!): kotlin.Unit
+    public open fun noBoundsNullable(/*0*/ a: A<out @org.jspecify.nullness.Nullable kotlin.Any!, out @org.jspecify.nullness.Nullable kotlin.Any!, out @org.jspecify.nullness.Nullable kotlin.Any!>!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jspecify/warnMode/WildcardsWithDefault.kt

@@ -1,6 +1,19 @@
-// JAVA_SOURCES: WildcardsWithDefault.java
-// JSPECIFY_STATE warn
+// WITH_FOREIGN_ANNOTATIONS
 
+// FILE: WildcardsWithDefault.java
+
+import org.jspecify.nullness.*;
+
+@NullMarked
+public class WildcardsWithDefault {
+    public void noBoundsNotNull(A<?, ?, ?> a) {}
+    public void noBoundsNullable(A<? extends @Nullable Object, ? extends @Nullable Object, ? extends @Nullable Object> a) {}
+}
+
+// FILE: A.java
+public class A <T extends Object, E extends @Nullable Object, F extends @NullnessUnspecified Object> {}
+
+// FILE: main.kt
 fun main(
             aNotNullNotNullNotNull: A<Any, Any, Any>,
             aNotNullNotNullNull: A<Any, Any, Any?>,
@@ -8,8 +21,8 @@ fun main(
             aNotNullNullNull: A<Any, Any?, Any?>,
             b: WildcardsWithDefault
 ): Unit {
-    // jspecify_nullness_mismatch
     b.noBoundsNotNull(aNotNullNotNullNotNull)
+    // jspecify_nullness_mismatch
     b.noBoundsNotNull(aNotNullNotNullNull)
     // jspecify_nullness_mismatch
     b.noBoundsNotNull(aNotNullNullNotNull)