Deal with `omitted` (dependencies) in selection

[edsko]

Blocked by #799.

Assigning this to @dschrempf , but it will depend on @TravisCardwell 's binding spec changes first.

[TravisCardwell]

There have been a lot of design changes lately, so I would like to confirm the desired behavior and make sure that we are on the same page.

Initial implementation:

omit is already implemented. The initial implementation removed dependencies on those omitted types in the UseDeclGraph, and selection therefore did not traverse those (transitive) dependencies. In addition, it passed on a Map of omitted types so that we could issue an error if a type is both omitted and selected.

Recent refactoring:

We now also use the DeclUseGraph, so we now update it to reflect the changes to the UseDeclGraph. We now categorize all declarations in the DeclIndex. Instead of passing on a Map of omitted types, the declaration needs to be "moved" from one category (succeeded) to another (omitted) within the DeclIndex, but I am not sure of the status of this.

Planned changes:

At one point, we talked about "recording omitted instances in the AST," but I do not see mention of this in the issue.

I think the idea is that omitted types should no longer be removed from the list of declarations. Currently, as of #1304, using the internal Frontend AST, a declaration is annotated with the following:

(Maybe BindingSpec.CTypeSpec, Maybe BindingSpec.HsTypeSpec)

Note that this type matches the semantics of how type specifications are used, so it is not as strict as the file format, where a Haskell type specification may only be specified when at least one corresponding C type specification is specified.

If we keep the omitted declarations, this annotation would change to the following, more closely matching the file format:

Maybe (Omittable (BindingSpec.CTypeSpec, Maybe BindingSpec.HsTypeSpec))

The Select pass would then need to check this annotation for every declaration that it processes. A value of Just Omit would indicate that the type is omitted by the prescriptive binding specification.

Is this accurate?

If so, I wonder what the Select pass will do. Will it also just annotate selection, so that later passes still see all "parsed" declarations but can check annotations to determine which are selected?