I'd like to delete the case tp: TypeProxy, since it will essentially widen a type.
Let's also move it next to isNotNull because of the similarity.

def admitsNull(using Context): Boolean =
  self.isNullType || self.isAny || self.dealias match
    case OrType(l, r) => r.admitsNull || l.admitsNull
    case AndType(l, r) => r.admitsNull && l.admitsNull
    case tp: TypeBounds => tp.lo.admitsNull
    case _: FlexibleType => true
    case _ => false

Without the TypeProxy case, the following test fails (no warning):

def f6[T >: String|Null](s: String|Null): T = s.nn // warn

Since the test is approximately NullType <:< tp, what's the downside of widening tp if the original narrow tp fails the test. (I can see that widening eagerly before the match would cause us to miss some cases.)

Will it be enough if we add a case for TypeRef and recur on its info?

That does cover this f6 test case, but would miss other cases such as AnnotatedType.

Do you have a particular example in mind where TypeProxy would do the wrong thing?

I'm ok with the current rule and can be merged, given a singleton type wouldn't be inferred at type argument places of nn.