--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gcc/testsuite/g++.dg/ipa/pr85421.C	Thu Oct 25 07:37:49 2018 +0900
@@ -0,0 +1,131 @@
+// { dg-do compile }
+// { dg-options "-O3 -std=gnu++1y -w" }
+
+namespace {
+template <typename b> b c(b);
+template <typename d, typename, template <typename> class> struct f {
+  using g = d;
+};
+template <typename d, template <typename> class aa> using h = f<d, void, aa>;
+template <typename d, template <typename> class aa>
+using i = typename h<d, aa>::g;
+template <typename b> struct j { typedef b k; };
+} // namespace
+namespace l {
+template <typename b> class m {
+public:
+  typedef b k;
+};
+} // namespace l
+namespace a {
+template <typename b> using n = l::m<b>;
+template <typename b> class ac : public n<b> {};
+struct s {
+  template <typename b> using ad = typename b::e;
+};
+template <typename o> struct p : s {
+  typedef typename o::k k;
+  using ag = i<k *, ad>;
+};
+} // namespace a
+namespace l {
+template <typename o> struct t : a::p<o> {};
+} // namespace l
+namespace a {
+template <bool> struct al {
+  template <typename am> static void an(am ao, am) { c(*ao); }
+};
+template <typename am> void aq(am ao, am ap) {
+  typedef typename j<am>::k ar;
+  al<__has_trivial_destructor(ar)>::an(ao, ap);
+}
+namespace {
+typedef char au;
+}
+} // namespace a
+typedef char av;
+typedef int aw;
+typedef av ay;
+typedef aw az;
+namespace a {
+template <typename, typename o> struct ba {
+  typedef typename l::t<o>::ag ag;
+  struct {
+    ag bb;
+    ag bc;
+  } bd;
+};
+template <typename b, typename o = ac<b>> class be : ba<b, o> {
+  typedef ba<b, o> bf;
+  typedef typename bf::ag ag;
+
+public:
+  void bh() { bi(this->bd.bb); }
+  void bi(ag bj) { aq(bj, this->bd.bc); }
+};
+} // namespace a
+namespace bk {
+enum bl {};
+enum bn { bo };
+class q {
+public:
+  static a::au bp(bn);
+  static bool bq(a::au *br, bn g) { return bs(br, g); }
+  static bl bs(a::au *br, bn g) {
+    if (br) {
+      auto bt = bp(g);
+      if (bt)
+        return bl();
+    }
+  }
+};
+template <typename, typename> class bu {};
+} // namespace bk
+namespace bv {
+namespace bw {
+class bx;
+}
+} // namespace bv
+namespace bk {
+enum by { bz };
+struct ca;
+class cb {
+public:
+  class cc {
+  public:
+    virtual void cd(by) = 0;
+  };
+  virtual bu<ca, by> e();
+  cc *cf;
+};
+class cg {
+public:
+  ~cg() { q::bq(ch, bo); }
+  a::au *ch;
+};
+class ci {
+  cg cj;
+};
+namespace ck {
+enum cl : ay;
+}
+class r : ci {};
+class cn {
+public:
+  ck::cl co();
+};
+by cp(ck::cl);
+class cq : cb, cb::cc {
+  bu<ca, by> ce(bv::bw::bx &, az) noexcept;
+  void cd(by);
+  void cr(bv::bw::bx &, az, cb::cc *) noexcept;
+  cn cs;
+  a::be<r> ct;
+};
+} // namespace bk
+using bv::bw::bx;
+namespace bk {
+bu<ca, by> cq::ce(bx &, az) noexcept { ct.bh(); }
+void cq::cr(bx &, az, cb::cc *) noexcept { cd(bz); }
+void cq::cd(by) { cf->cd(cp(cs.co())); }
+} // namespace bk