Concerns about implementation, for anyone taking this on:

1. Currently, all #if directives are resolved while parsing code, while import decls are resolved right at the start of "type-checking" (semantic analysis) in a step called "name-binding". (The name is a bit outdated, but the function is still called performNameBinding IIRC.

2. Parsing must not resolve imports, because we use parsing to do simple and fast syntax highlighting that should be useful even in the presence of source errors.

I think this means the best approach is allowing #if blocks to be unresolved after parsing and resolve them in the performNameBinding step. A possible refinement would postpone resolving #if blocks inside function and closure bodies until the function or closure was type-checked; at that point it would become a pre-processing pass when type-checking a function body.

Implementation so far is here (master...CodaFi:fine-imported-goods). Down to just some failing IDE tests!

Is this still a candidate for Swift 4?

No one was able to spend more time on it since Robert's initial implementation was found to be flawed. At this point that means it probably won't make Swift 4 either.

@rintaro Is making good progress with the refactoring around this. The hardest part here is going to be lazier evaluation of conditions and rebinding declrefs that are shadowed by the introduction of variables in a condition. The latter problem could be solved by removing inner decl refs from the scope map and, when we evaluate the condition, run a walker that rebinds just those decl refs in our scope. It would have to be done in Sema, before or during the initial phase of type checking

After speaking with Ben, we came up with a compromise. See #11613

Resolved by the merger of the previously linked pull request.