Updated getNullabilityAnnotation for checkers

[chrisbazley]

Summary

NullabilityChecker and TrustNonnullChecker use
a pre-existing helper function,
getNullabilityAnnotation() to get a Nullability
value from a QualType.

That function is now updated to return
Nullability::Nullable if the given type is a
pointer to an _Optional-qualified type. The
purpose is to allow declarations such as

_Optional int *x;

to be treated (for static analysis purposes) as
equivalent to

int *_Nullable x;

thereby removing one barrier to adoption of the
_Optional type qualifier.

[chrisbazley]

Please refer to https://discourse.llvm.org/t/rfc-optional-a-type-qualifier-to-indicate-pointer-nullability/ and https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3089.pdf for the wider context of this commit.

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

Contradicted, // Tracked nullability is contradicted by an explicit cast. Do
                 // not report any nullability related issue for this symbol.
                 // This nullability is propagated aggressively to avoid false
                 // positive results. See the comment on getMostNullable method.
   Nullable,
   Unspecified,
   Nonnull
 };
 
+/// Find out whether the given type is a pointer to an optional value.
+/// If true then the pointer value should be treated as nullable.
+bool pointeeIsOptional(QualType Type);
+
 /// Get nullability annotation for a given type.
 Nullability getNullabilityAnnotation(QualType Type);
 
 /// Try to parse the value of a defined preprocessor macro. We can only parse
 /// simple expressions that consist of an optional minus sign token and then a
 /// token for an integer. If we cannot parse the value then std::nullopt is
 /// returned.
 std::optional<int> tryExpandAsInteger(StringRef Macro, const Preprocessor &PP);

clang/lib/StaticAnalyzer/Core/CheckerHelpers.cpp

if (auto Assign = dyn_cast_or_null<BinaryOperator>(S)) {
     assert(PD->isSingleDecl() && "We process decls one by one");
     VD = cast<VarDecl>(PD->getSingleDecl());
     RHS = VD->getAnyInitializer();
   }
 
   return std::make_pair(VD, RHS);
 }
 
+bool pointeeIsOptional(QualType Type) {
+  if (const PointerType *PT = Type->getAs<PointerType>()) {
+    auto PointeeType = PT->getPointeeType();
+    if (PointeeType.isOptionalQualified()) {
+      return true;
+    }
+  }
+  return false;
+}
+
 Nullability getNullabilityAnnotation(QualType Type) {
+  if (pointeeIsOptional(Type)) {
+    return Nullability::Nullable;
+  }
+
   const auto *AttrType = Type->getAs<AttributedType>();
   if (!AttrType)
     return Nullability::Unspecified;
   if (AttrType->getAttrKind() == attr::TypeNullable)
     return Nullability::Nullable;
   else if (AttrType->getAttrKind() == attr::TypeNonNull)
     return Nullability::Nonnull;
   return Nullability::Unspecified;