[analyzer][NFC] Make the API of CallDescription safer slightly

[steakhal]

Summary

The new deleted constructor overload makes sure that no implicit
conversion from 0 would happen to ArrayRef<const char*>.

Also adds nodiscard to the CallDescriptionMap::lookup()

[martong]

The new deleted constructor overload makes sure that no implicit
conversion from 0 would happen to ArrayRef<const char*>.

Did you encounter a call with a nullptr?

[xazax.hun]

Are there other classes in LLVM taking a single ArrayRef in the constructor? Are they using similar techniques to avoid potential problems?

[steakhal]

In D113588#3127637, @martong wrote:

The new deleted constructor overload makes sure that no implicit
conversion from 0 would happen to ArrayRef<const char*>.

Did you encounter a call with a nullptr?

I did not. But it makes sense to delete: https://quuxplusone.github.io/blog/2021/10/17/equals-delete-means/

In D113588#3127764, @xazax.hun wrote:

Are there other classes in LLVM taking a single ArrayRef in the constructor?

I don't know.

Are they using similar techniques to avoid potential problems?

They should.

[Szelethus]

I guess this constructor prevents us from to just put this into ArrayRef:

/// Construct an ArrayRef from a single element.
/*implicit*/ ArrayRef(const T &OneElt)
  : Data(&OneElt), Length(1) {}

I guess this is a "why not" patch, so, LGTM!

[steakhal]

I've accidentally committed this without mentioning the Differential Revision stuff in the commit message. :(
This landed with 35ff3a0095d5b2dafa2fc8dd762377342aef9c50

How to address this?

[whisperity]

In D113588#3137584, @steakhal wrote:

I've accidentally committed this without mentioning the Differential Revision stuff in the commit message. :(
This landed with 35ff3a0095d5b2dafa2fc8dd762377342aef9c50

How to address this?

There is no way, as we do not have rights to force push the official upstream master.
The link is good enough. Maybe some Phabricator admin can force the connection manually.

Otherwise, whatever. The commit is in, that's it.

[ASDenysPetrov]

In D113588#3137584, @steakhal wrote:

How to address this?

I think mentioning this is already enough. :)

clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallDescription.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_CALLDESCRIPTION_H
 #define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_CALLDESCRIPTION_H
 
 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/Support/Compiler.h"
 #include <vector>
 
 namespace clang {
 class IdentifierInfo;
 } // namespace clang
 
 namespace clang {
 namespace ento {
CallDescription(int Flags, ArrayRef<const char *> QualifiedName,
                   Optional<unsigned> RequiredArgs = None,
                   Optional<size_t> RequiredParams = None);
 
   /// Construct a CallDescription with default flags.
   CallDescription(ArrayRef<const char *> QualifiedName,
                   Optional<unsigned> RequiredArgs = None,
                   Optional<size_t> RequiredParams = None);
 
+  CallDescription(std::nullptr_t) = delete;
+
   /// Get the name of the function that this object matches.
   StringRef getFunctionName() const { return QualifiedName.back(); }
 
   /// Get the qualified name parts in reversed order.
   /// E.g. { "std", "vector", "data" } -> "vector", "std"
   auto begin_qualified_name_parts() const {
     return std::next(QualifiedName.rbegin());
   }
public:
 
   ~CallDescriptionMap() = default;
 
   // These maps are usually stored once per checker, so let's make sure
   // we don't do redundant copies.
   CallDescriptionMap(const CallDescriptionMap &) = delete;
   CallDescriptionMap &operator=(const CallDescription &) = delete;
 
-  const T *lookup(const CallEvent &Call) const {
+  LLVM_NODISCARD const T *lookup(const CallEvent &Call) const {
     // Slow path: linear lookup.
     // TODO: Implement some sort of fast path.
     for (const std::pair<CallDescription, T> &I : LinearMap)
       if (Call.isCalled(I.first))
         return &I.second;
 
     return nullptr;
   }
 };
 
 } // namespace ento
 } // namespace clang
 
 #endif // LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_CALLDESCRIPTION_H