C++ PATCH for c++/92106 - ICE with structured bindings and -Wreturn-local-addr

[Marek Polacek]

Here we are returning the address of a structure binding and since it's a
reference, we recursed on its initializer, but in this case there was none
and we crashed in cp_fold.  So don't recurse when we don't have an init to
recurse on.

Bootstrapped/regtested on x86_64-linux, ok for trunk/9?

2019-10-15  Marek Polacek  <pola...@redhat.com>

        PR c++/92106 - ICE with structured bindings and -Wreturn-local-addr.
        * typeck.c (maybe_warn_about_returning_address_of_local): Avoid
        recursing on null initializer.

        * g++.dg/cpp1z/decomp50.C: New test.

diff --git gcc/cp/typeck.c gcc/cp/typeck.c
index 141d86f50c9..1825540016f 100644
--- gcc/cp/typeck.c
+++ gcc/cp/typeck.c
@@ -9354,10 +9354,8 @@ maybe_warn_about_returning_address_of_local (tree retval)
             binding.  */
          tree base = DECL_DECOMP_BASE (whats_returned);
          if (TYPE_REF_P (TREE_TYPE (base)))
-           {
-             tree init = DECL_INITIAL (base);
+           if (tree init = DECL_INITIAL (base))
              return maybe_warn_about_returning_address_of_local (init);
-           }
        }
       bool w = false;
       auto_diagnostic_group d;
diff --git gcc/testsuite/g++.dg/cpp1z/decomp50.C 
gcc/testsuite/g++.dg/cpp1z/decomp50.C
new file mode 100644
index 00000000000..c41c0d8cbbf
--- /dev/null
+++ gcc/testsuite/g++.dg/cpp1z/decomp50.C
@@ -0,0 +1,49 @@
+// PR c++/92106 - ICE with structured bindings and -Wreturn-local-addr. 
+// { dg-do compile { target c++17 } }
+
+template <typename> struct B;
+template <typename _Tp> struct B<_Tp *> { typedef _Tp reference; };
+struct C {
+  template <typename _Up> using rebind = _Up *;
+};
+template <typename _Iterator, typename> class D {
+public:
+  typename B<_Iterator>::reference operator*();
+  void operator++();
+};
+
+template <typename _Iterator, typename _Container>
+bool operator!=(D<_Iterator, _Container>, D<_Iterator, _Container>);
+template <typename _Tp> class F {
+public:
+  typedef _Tp value_type;
+};
+
+template <typename _Alloc> struct G {
+  template <typename _Tp> struct H { using type = C::rebind<_Tp>; };
+  using const_pointer = typename H<typename _Alloc::value_type>::type;
+};
+template <typename _Tp, typename _Alloc = F<_Tp>> class I {
+  typedef D<typename G<_Alloc>::const_pointer, int> const_iterator;
+
+public:
+  const_iterator begin();
+  const_iterator end();
+};
+
+struct A {
+  struct J {
+    int name;
+    int value;
+  };
+  I<J> members;
+  template <typename Key> const int *find(Key) {
+    for (const auto &[name, value] : members)
+      return &value; // { dg-warning "address of local variable" }
+    return nullptr;
+  }
+};
+int main() {
+  A a;
+  a.find("");
+}