I believe this is an analogous test case that doesn't involve macros and Dynamic.

class D[T <: Bound](t: T) { type TT = T}
object Test {
  object C extends D(1)
  implicit val unrelated: List[C.TT] = null // error: illegal cyclic reference involving object C
}
class Bound
object Bound {
  implicit def AnyToBound[T](t: T): Bound = new Bound
}

Could you check whether this PR fixes it, too, and add it as an extra test case?

My understanding of ImplicitInfo#computeIsCyclicOrErroneous is that even after you've suppressed the unwanted reporting of the cyclic error, the implicit will still be out of service as the ImplicitInfo is cached. I think there are different instances of ImplicitInfo to represent the in-scope implicits (Context#implicitss) vs the companion scope implicits (Implicits#implicitsOfExpectedType), so in- or out-of-service might vary depending on how you consume the implicit.

That's a good point, about the caching. Currently, adding val i = implicitly[List[K]] to my test gives a "could not find implicit" error, but val i: List[K] = implicitly[List[K]] does not... it appears that the implicit cache gets cleared at some point.

I'm not quite sure what can be done about that: the most direct fix I can think of would be to not cache isCyclicOrErroneous for locked symbols, but that seems like it would come across as somewhat arcane. What do you think?

Also, I cannot get your test case to compile. On 2.12.1, the cyclic reference error appears, but with other errors as well:

<pastie>:13: error: inferred type arguments [Int] do not conform to class D's type parameter bounds [T <: Bound]
         object C extends D(1)
                          ^
<pastie>:13: error: type mismatch;
 found   : Int(1)
 required: T
         object C extends D(1)

However, with this change the cyclic reference error vanishes (but those two remain).

I've been digging around a bit (apologies for taking so long!), and it looks like your PR reveals some much deeper issues! When changing the type alias to

  type K = Record.bip.type#T // was `Record.bip.T`

the example compiles without error, even though that should be an equivalent formulation (it works because implicit search is correctly disabled when typing Record.bip.type). That's the first issue (code duplication ftw): typing a Select(qual, name), where name.isTypeName, should behave the same as SelectFromTypeTree(SingletonTypeTree(qual), name).

Secondly, and sadly, I think neither version should compile, as the [select|apply]Dynamic expansion was never intended to happen in types... Without macros, it wasn't possible to escape the stable identifier requirement, so it didn't occur to me to check that explicitly.

/cc @odersky for advice on wwdd (what would dotty do)

Secondly, and sadly, I think neither version should compile,

To clarify, for backwards compatibility we won't disallow this in 2.12.x, but I expect this loophole to be closed. I have a PR in the making that implements your initial observation that implicit search should not be used while type checking the qualifier of a type selection. (Which makes your test case compile)

@adriaanm has looked deeper and found a much nicer solution... closing for now