[clangd] Fix a crash for accessing a null field decl returned by findExplicitReferences.

[kadircet]

clang-tools-extra/clangd/FindTarget.cpp

717

thanks for fixing this !

But I suppose we should rather return a result with empty TargetDecl as this is what API promises:

/// For dependent and unresolved references, Targets can also be empty.

[hokein]

emit empty decl and simplify the testcase.

clang-tools-extra/clangd/FindTarget.cpp

void VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *E) {
           // Select the getter, setter, or @property depending on the call.
           explicitReferenceTargets(DynTypedNode::create(*E), {})});
     }
 
     void VisitDesignatedInitExpr(const DesignatedInitExpr *DIE) {
       for (const DesignatedInitExpr::Designator &D : DIE->designators()) {
         if (!D.isFieldDesignator())
           continue;
-        Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
-                                    D.getFieldLoc(),
-                                    /*IsDecl=*/false,
-                                    {D.getField()}});
+
+        llvm::SmallVector<const NamedDecl *, 1> Targets;
+        if (D.getField())
+          Targets.push_back(D.getField());
+        Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(), D.getFieldLoc(),
+                                    /*IsDecl=*/false, std::move(Targets)});
       }
     }
   };
 
   Visitor V;
   V.Visit(E);
   return V.Refs;
 }

clang-tools-extra/clangd/unittests/FindTargetTests.cpp

#endif
         "0: targets = {Baz}, decl\n"
         "1: targets = {foo()::Baz::Field}, decl\n"
         "2: targets = {Bar}, decl\n"
         "3: targets = {Baz}\n"
         "4: targets = {foo()::Bar::Foo}, decl\n"
         "5: targets = {Bar}\n"
         "6: targets = {bar}, decl\n"
         "7: targets = {foo()::Bar::Foo}\n"
-        "8: targets = {foo()::Baz::Field}\n"}};
+        "8: targets = {foo()::Baz::Field}\n"},
+      {R"cpp(
+           template<typename T>
+           void crash(T);
+           template<typename T>
+           void foo() {
+             $0^crash({.$1^x = $2^T()});
+           }
+        )cpp",
+        "0: targets = {crash}\n"
+        "1: targets = {}\n"
+        "2: targets = {T}\n"
+      },
+    };
 
   for (const auto &C : Cases) {
     llvm::StringRef ExpectedCode = C.first;
     llvm::StringRef ExpectedRefs = C.second;
 
     auto Actual =
         annotateReferencesInFoo(llvm::Annotations(ExpectedCode).code());
     EXPECT_EQ(ExpectedCode, Actual.AnnotatedCode);
     EXPECT_EQ(ExpectedRefs, Actual.DumpedReferences) << ExpectedCode;
   }
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang