It might be valuable to answer both: P transitively uses generics, and P uses generics itself. But yeah if we need to choose exactly one to implement, it is P transitively uses generics. This can be done as a package Fact.

Change https://golang.org/cl/355009 mentions this issue: go/analysis/passes/usesgenerics: a new analysis to detect generic code

I think it would be super useful if the analyzer could distinguish whether a package only "uses" generics or doesn't need to know about generics at all.

For example consider three packages A, B, C, where A depends on B, and B depends on C.
C defines a generic type or function.
B may or may not instantiate a type from C, but doesn't expose (export) any generic types (or functions).
Then A would "just" use B without knowing having to know anything about generics.

It would be great, if we could distinguish between these 3 cases, because it would allow us to experiment with generics in a more controlled way.

I think this could also be realized as a Fact (but I might be wrong).

WDYT?

Hi @chressie -- in CL 355009 I distinguish five different 'generics' features, and report which are used directly vs transitively.

This may answer some of your questions: we would see that A does not directly use any generics features, and that B only directly uses instantiation. However, I think there's a more subtle interpretation of your request: can we compute whether B 'exposes' any generics features.

This more subtle interpretation is non-trivial to compute: see the objectpath package for an algorithm to find 'reachable' objects. It's even harder (and likely infeasible) to prove that the dynamic type of an interface can never be e.g. an instantiated type.

I've added you as a reviewer of that CL. Would it meet your needs?

Thanks for your quick reply! I'll comment on the CL.