[clang] Add a new nullability annotation for swift async: _Nullable_result

[erik.pilkington]

Summary

You can read more about the clang attributes for swift async here:
https://github.com/DougGregor/swift-evolution/blob/concurrency-objc/proposals/NNNN-concurrency-objc.md

rdar://70106409

Thanks for taking a look!

[doug.gregor]

This looks great to me, thank you!

[aaron.ballman]

clang/include/clang/Basic/AttrDocs.td

3516

its -> it's

3526

Swift imported -> Swift importer

clang/lib/Basic/IdentifierTable.cpp

718–719

Can you explain why it differs from _Nullable in this case?

clang/lib/Sema/SemaExprObjC.cpp

1566

Should that be auto *?

1573

Same here.

[erik.pilkington]

Address review comments.

clang/lib/Basic/IdentifierTable.cpp

718–719

Sure, _Nullable can be written like nullable in an @property or method return/param type i.e.:

@property(nullable) id x;

_Nullable_result isn't really useful in these contexts (you should always use nullable there), so I didn't add parsing support for it.

clang/lib/Sema/SemaExprObjC.cpp

1566

Its an Optional<NullabilityKind>, so I guess it should really be written out. New patch drops the auto.

[doug.gregor]

clang/test/SemaObjC/nullable-result.m

7

Can you add a __has_attribute check for _Nullable_result?

[aaron.ballman]

LGTM aside from the testing requests.

clang/lib/Basic/IdentifierTable.cpp

718–719

Ah, thank you for the explanation!

clang/test/SemaObjC/nullability.m

119

Can you add a test case that shows - (nullable_result id)returnsNullableResultErr; doesn't work (but also doesn't do something bad, like assert)?

[erik.pilkington]

Address review comments.

clang/test/SemaObjC/nullable-result.m

7

Hmm, it looks like __has_attribute doesn't support keyword attributes. I'll add a __has_feature.

clang/include/clang-c/Index.h

enum CXTypeNullabilityKind {
    * unspecified. This captures a (fairly rare) case where we
    * can't conclude anything about the nullability of the type even
    * though it has been considered.
    */
   CXTypeNullability_Unspecified = 2,
   /**
    * Nullability is not applicable to this type.
    */
-  CXTypeNullability_Invalid = 3
+  CXTypeNullability_Invalid = 3,
+
+  /**
+   * Generally behaves like Nullable, except when used in a block parameter that
+   * was imported into a swift async method. There, swift will assume that the
+   * parameter can get null even if no error occured. _Nullable parameters are
+   * assumed to only get null on error.
+   */
+  CXTypeNullability_NullableResult = 4
 };
 
 /**
  * Retrieve the nullability kind of a pointer type.
  */
 CINDEX_LINKAGE enum CXTypeNullabilityKind clang_Type_getNullability(CXType T);
 
 /**

clang/include/clang/AST/Type.h

public:
   static Kind getNullabilityAttrKind(NullabilityKind kind) {
     switch (kind) {
     case NullabilityKind::NonNull:
       return attr::TypeNonNull;
 
     case NullabilityKind::Nullable:
       return attr::TypeNullable;
 
+    case NullabilityKind::NullableResult:
+      return attr::TypeNullableResult;
+
     case NullabilityKind::Unspecified:
       return attr::TypeNullUnspecified;
     }
     llvm_unreachable("Unknown nullability kind.");
   }
 
   /// Strip off the top-level nullability annotation on the given
   /// type, if it's there.

clang/include/clang/Basic/Attr.td

def TypeNonNull : TypeAttr {
   let Documentation = [TypeNonNullDocs];
 }
 
 def TypeNullable : TypeAttr {
   let Spellings = [Keyword<"_Nullable">];
   let Documentation = [TypeNullableDocs];
 }
 
+def TypeNullableResult : TypeAttr {
+  let Spellings = [Keyword<"_Nullable_result">];
+  let Documentation = [TypeNullableResultDocs];
+}
+
 def TypeNullUnspecified : TypeAttr {
   let Spellings = [Keyword<"_Null_unspecified">];
   let Documentation = [TypeNullUnspecifiedDocs];
 }
 
 // This is a marker used to indicate that an __unsafe_unretained qualifier was
 // ignored because ARC is not enabled. The usual representation for this
 // qualifier is as an ObjCOwnership attribute with Kind == "none".

clang/include/clang/Basic/AttrDocs.td

``_Nullable`` pointer type can be null. For example, given:
   .. code-block:: c
 
     int fetch_or_zero(int * _Nullable ptr);
 
 a caller of ``fetch_or_zero`` can provide null.
   }];
 }
 
+def TypeNullableResultDocs : Documentation {
+  let Category = NullabilityDocs;
+  let Content = [{
+The ``_Nullable_result`` nullability qualifier means that a value of the
+``_Nullable_result`` pointer can be ``nil``, just like ``_Nullable``. Where this
+attribute differs from ``_Nullable`` is when it's used on a parameter to a
+completion handler in a Swift async method. For instance, here:
+
+  .. code-block:: objc
+
+    -(void)fetchSomeDataWithID:(int)identifier
+             completionHandler:(void (^)(Data *_Nullable_result result, NSError *error))completionHandler;
+
+This method asynchronously calls ``completionHandler`` when the data is
+available, or calls it with an error. ``_Nullable_result`` indicates to the
+Swift importer that this is the uncommon case where ``result`` can get ``nil``
+even if no error has occured, and will therefore import it as a Swift optional
+type. Otherwise, if ``result`` was annotated with ``_Nullable``, the Swift
+importer will assume that ``result`` will always be non-nil unless an error
+occured.
+}];
+}
+
 def TypeNullUnspecifiedDocs : Documentation {
   let Category = NullabilityDocs;
   let Content = [{
 The ``_Null_unspecified`` nullability qualifier indicates that neither the
 ``_Nonnull`` nor ``_Nullable`` qualifiers make sense for a particular pointer
 type. It is used primarily to indicate that the role of null with specific
 pointers in a nullability-annotated header is unclear, e.g., due to
 overly-complex implementations or historical factors with a long-lived API.

clang/include/clang/Basic/Features.def

 FEATURE(attribute_diagnose_if_objc, true)
 FEATURE(blocks, LangOpts.Blocks)
 FEATURE(c_thread_safety_attributes, true)
 FEATURE(cxx_exceptions, LangOpts.CXXExceptions)
 FEATURE(cxx_rtti, LangOpts.RTTI &&LangOpts.RTTIData)
 FEATURE(enumerator_attributes, true)
 FEATURE(nullability, true)
 FEATURE(nullability_on_arrays, true)
+FEATURE(nullability_nullable_result, true)
 FEATURE(memory_sanitizer,
         LangOpts.Sanitize.hasOneOf(SanitizerKind::Memory |
                                    SanitizerKind::KernelMemory))
 FEATURE(thread_sanitizer, LangOpts.Sanitize.has(SanitizerKind::Thread))
 FEATURE(dataflow_sanitizer, LangOpts.Sanitize.has(SanitizerKind::DataFlow))
 FEATURE(scudo, LangOpts.Sanitize.hasOneOf(SanitizerKind::Scudo))
 // Objective-C features
 FEATURE(objc_arr, LangOpts.ObjCAutoRefCount) // FIXME: REMOVE?

clang/include/clang/Basic/Specifiers.h

enum class NullabilityKind : uint8_t {
     /// Values of this type can never be null.
     NonNull = 0,
     /// Values of this type can be null.
     Nullable,
     /// Whether values of this type can be null is (explicitly)
     /// unspecified. This captures a (fairly rare) case where we
     /// can't conclude anything about the nullability of the type even
     /// though it has been considered.
-    Unspecified
+    Unspecified,
+    // Generally behaves like Nullable, except when used in a block parameter
+    // that was imported into a swift async method. There, swift will assume
+    // that the parameter can get null even if no error occured. _Nullable
+    // parameters are assumed to only get null on error.
+    NullableResult,
   };
 
   /// Return true if \p L has a weaker nullability annotation than \p R. The
   /// ordering is: Unspecified < Nullable < NonNull.
   inline bool hasWeakerNullability(NullabilityKind L, NullabilityKind R) {
     return uint8_t(L) > uint8_t(R);
   }
 

clang/include/clang/Basic/TokenKinds.def

 ALIAS("__typeof"     , typeof     , KEYALL)
 ALIAS("__typeof__"   , typeof     , KEYALL)
 ALIAS("__volatile"   , volatile   , KEYALL)
 ALIAS("__volatile__" , volatile   , KEYALL)
 
 // Type nullability.
 KEYWORD(_Nonnull                 , KEYALL)
 KEYWORD(_Nullable                , KEYALL)
+KEYWORD(_Nullable_result         , KEYALL)
 KEYWORD(_Null_unspecified        , KEYALL)
 
 // Microsoft extensions which should be disabled in strict conformance mode
 KEYWORD(__ptr64                       , KEYMS)
 KEYWORD(__ptr32                       , KEYMS)
 KEYWORD(__sptr                        , KEYMS)
 KEYWORD(__uptr                        , KEYMS)
 KEYWORD(__w64                         , KEYMS)

clang/include/clang/Sema/Sema.h

private:
   Scope *CurScope;
 
   mutable IdentifierInfo *Ident_super;
   mutable IdentifierInfo *Ident___float128;
 
   /// Nullability type specifiers.
   IdentifierInfo *Ident__Nonnull = nullptr;
   IdentifierInfo *Ident__Nullable = nullptr;
+  IdentifierInfo *Ident__Nullable_result = nullptr;
   IdentifierInfo *Ident__Null_unspecified = nullptr;
 
   IdentifierInfo *Ident_NSError = nullptr;
 
   /// The handler for the FileChanged preprocessor events.
   ///
   /// Used for diagnostics that implement custom semantic analysis for #include
   /// directives, like -Wpragma-pack.

clang/lib/APINotes/APINotesYAMLCompiler.cpp

 
 namespace llvm {
 namespace yaml {
 template <> struct ScalarEnumerationTraits<NullabilityKind> {
   static void enumeration(IO &IO, NullabilityKind &NK) {
     IO.enumCase(NK, "Nonnull", NullabilityKind::NonNull);
     IO.enumCase(NK, "Optional", NullabilityKind::Nullable);
     IO.enumCase(NK, "Unspecified", NullabilityKind::Unspecified);
+    IO.enumCase(NK, "NullableResult", NullabilityKind::NullableResult);
     // TODO: Mapping this to it's own value would allow for better cross
     // checking. Also the default should be Unknown.
     IO.enumCase(NK, "Scalar", NullabilityKind::Unspecified);
 
     // Aliases for compatibility with existing APINotes.
     IO.enumCase(NK, "N", NullabilityKind::NonNull);
     IO.enumCase(NK, "O", NullabilityKind::Nullable);
     IO.enumCase(NK, "U", NullabilityKind::Unspecified);

clang/lib/AST/Type.cpp

bool AttributedType::isQualifier() const {
   // These are type qualifiers in the traditional C sense: they annotate
   // something about a specific value/variable of a type.  (They aren't
   // always part of the canonical type, though.)
   case attr::ObjCGC:
   case attr::ObjCOwnership:
   case attr::ObjCInertUnsafeUnretained:
   case attr::TypeNonNull:
   case attr::TypeNullable:
+  case attr::TypeNullableResult:
   case attr::TypeNullUnspecified:
   case attr::LifetimeBound:
   case attr::AddressSpace:
     return true;
 
   // All other type attributes aren't qualifiers; they rewrite the modified
   // type to be a semantically different type.
   default:

 llvm::Optional<NullabilityKind>
 AttributedType::getImmediateNullability() const {
   if (getAttrKind() == attr::TypeNonNull)
     return NullabilityKind::NonNull;
   if (getAttrKind() == attr::TypeNullable)
     return NullabilityKind::Nullable;
   if (getAttrKind() == attr::TypeNullUnspecified)
     return NullabilityKind::Unspecified;
+  if (getAttrKind() == attr::TypeNullableResult)
+    return NullabilityKind::NullableResult;
   return None;
 }
 
 Optional<NullabilityKind> AttributedType::stripOuterNullability(QualType &T) {
   QualType AttrTy = T;
   if (auto MacroTy = dyn_cast<MacroQualifiedType>(T))
     AttrTy = MacroTy->getUnderlyingType();
 

clang/lib/AST/TypePrinter.cpp

void TypePrinter::printAttributedBefore(const AttributedType *T,
   // Print nullability type specifiers.
   if (T->getImmediateNullability()) {
     if (T->getAttrKind() == attr::TypeNonNull)
       OS << " _Nonnull";
     else if (T->getAttrKind() == attr::TypeNullable)
       OS << " _Nullable";
     else if (T->getAttrKind() == attr::TypeNullUnspecified)
       OS << " _Null_unspecified";
+    else if (T->getAttrKind() == attr::TypeNullableResult)
+      OS << " _Nullable_result";
     else
       llvm_unreachable("unhandled nullability");
     spaceBeforePlaceHolder(OS);
   }
 }
 
 void TypePrinter::printAttributedAfter(const AttributedType *T,
                                        raw_ostream &OS) {
#include "clang/Basic/AttrList.inc"
   case attr::OpenCLGenericAddressSpace:
     // FIXME: Update printAttributedBefore to print these once we generate
     // AttributedType nodes for them.
     break;
 
   case attr::LifetimeBound:
   case attr::TypeNonNull:
   case attr::TypeNullable:
+  case attr::TypeNullableResult:
   case attr::TypeNullUnspecified:
   case attr::ObjCGC:
   case attr::ObjCInertUnsafeUnretained:
   case attr::ObjCKindOf:
   case attr::ObjCOwnership:
   case attr::Ptr32:
   case attr::Ptr64:
   case attr::SPtr:

clang/lib/Basic/Diagnostic.cpp

const StreamingDiagnostic &clang::operator<<(const StreamingDiagnostic &DB,
 
   case NullabilityKind::Nullable:
     string = nullability.second ? "'nullable'" : "'_Nullable'";
     break;
 
   case NullabilityKind::Unspecified:
     string = nullability.second ? "'null_unspecified'" : "'_Null_unspecified'";
     break;
+
+  case NullabilityKind::NullableResult:
+    assert(!nullability.second &&
+           "_Nullable_result isn't supported as context-sensitive keyword");
+    string = "_Nullable_result";
+    break;
   }
 
   DB.AddString(string);
   return DB;
 }
 
 const StreamingDiagnostic &clang::operator<<(const StreamingDiagnostic &DB,
                                              llvm::Error &&E) {

clang/lib/Basic/IdentifierTable.cpp

StringRef clang::getNullabilitySpelling(NullabilityKind kind,
                                         bool isContextSensitive) {
   switch (kind) {
   case NullabilityKind::NonNull:
     return isContextSensitive ? "nonnull" : "_Nonnull";
 
   case NullabilityKind::Nullable:
     return isContextSensitive ? "nullable" : "_Nullable";
 
+  case NullabilityKind::NullableResult:
+    assert(!isContextSensitive &&
+           "_Nullable_result isn't supported as context-sensitive keyword");
+    return "_Nullable_result";
+
   case NullabilityKind::Unspecified:
     return isContextSensitive ? "null_unspecified" : "_Null_unspecified";
   }
   llvm_unreachable("Unknown nullability kind.");
 }

clang/lib/Parse/ParseDecl.cpp

 }
 
 void Parser::ParseNullabilityTypeSpecifiers(ParsedAttributes &attrs) {
   // Treat these like attributes, even though they're type specifiers.
   while (true) {
     switch (Tok.getKind()) {
     case tok::kw__Nonnull:
     case tok::kw__Nullable:
+    case tok::kw__Nullable_result:
     case tok::kw__Null_unspecified: {
       IdentifierInfo *AttrName = Tok.getIdentifierInfo();
       SourceLocation AttrNameLoc = ConsumeToken();
       if (!getLangOpts().ObjC)
         Diag(AttrNameLoc, diag::ext_nullability)
           << AttrName;
       attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
                    ParsedAttr::AS_Keyword);
while (1) {
     // OpenCL single token adornments.
     case tok::kw___kernel:
       ParseOpenCLKernelAttributes(DS.getAttributes());
       continue;
 
     // Nullability type specifiers.
     case tok::kw__Nonnull:
     case tok::kw__Nullable:
+    case tok::kw__Nullable_result:
     case tok::kw__Null_unspecified:
       ParseNullabilityTypeSpecifiers(DS.getAttributes());
       continue;
 
     // Objective-C 'kindof' types.
     case tok::kw___kindof:
       DS.getAttributes().addNew(Tok.getIdentifierInfo(), Loc, nullptr, Loc,
                                 nullptr, 0, ParsedAttr::AS_Keyword);
#include "clang/Basic/OpenCLImageTypes.def"
   case tok::kw___w64:
   case tok::kw___ptr64:
   case tok::kw___ptr32:
   case tok::kw___pascal:
   case tok::kw___unaligned:
 
   case tok::kw__Nonnull:
   case tok::kw__Nullable:
+  case tok::kw__Nullable_result:
   case tok::kw__Null_unspecified:
 
   case tok::kw___kindof:
 
   case tok::kw___private:
   case tok::kw___local:
   case tok::kw___global:
   case tok::kw___constant:
bool Parser::isDeclarationSpecifier(bool DisambiguatingWithExpression) {
   case tok::kw___ptr64:
   case tok::kw___ptr32:
   case tok::kw___forceinline:
   case tok::kw___pascal:
   case tok::kw___unaligned:
 
   case tok::kw__Nonnull:
   case tok::kw__Nullable:
+  case tok::kw__Nullable_result:
   case tok::kw__Null_unspecified:
 
   case tok::kw___kindof:
 
   case tok::kw___private:
   case tok::kw___local:
   case tok::kw___global:
   case tok::kw___constant:
case tok::kw___pascal:
         ParseBorlandTypeAttributes(DS.getAttributes());
         continue;
       }
       goto DoneWithTypeQuals;
 
     // Nullability type specifiers.
     case tok::kw__Nonnull:
     case tok::kw__Nullable:
+    case tok::kw__Nullable_result:
     case tok::kw__Null_unspecified:
       ParseNullabilityTypeSpecifiers(DS.getAttributes());
       continue;
 
     // Objective-C 'kindof' types.
     case tok::kw___kindof:
       DS.getAttributes().addNew(Tok.getIdentifierInfo(), Loc, nullptr, Loc,
                                 nullptr, 0, ParsedAttr::AS_Keyword);

clang/lib/Parse/ParseTentative.cpp

if (Tok.isOneOf(tok::star, tok::amp, tok::caret, tok::ampamp) ||
       ConsumeAnyToken();
 
       // Skip attributes.
       if (!TrySkipAttributes())
         return TPResult::Error;
 
       while (Tok.isOneOf(tok::kw_const, tok::kw_volatile, tok::kw_restrict,
                          tok::kw__Nonnull, tok::kw__Nullable,
-                         tok::kw__Null_unspecified, tok::kw__Atomic))
+                         tok::kw__Nullable_result, tok::kw__Null_unspecified,
+                         tok::kw__Atomic))
         ConsumeToken();
     } else {
       return TPResult::True;
     }
   }
 }
 
 ///         operator-function-id:
Parser::isCXXDeclarationSpecifier(Parser::TPResult BracedCastResult,
   case tok::kw___sptr:
   case tok::kw___uptr:
   case tok::kw___ptr64:
   case tok::kw___ptr32:
   case tok::kw___forceinline:
   case tok::kw___unaligned:
   case tok::kw__Nonnull:
   case tok::kw__Nullable:
+  case tok::kw__Nullable_result:
   case tok::kw__Null_unspecified:
   case tok::kw___kindof:
     return TPResult::True;
 
     // Borland
   case tok::kw___pascal:
     return TPResult::True;
 

clang/lib/Sema/Sema.cpp

void Sema::PrintStats() const {
   BumpAlloc.PrintStats();
   AnalysisWarnings.PrintStats();
 }
 
 void Sema::diagnoseNullableToNonnullConversion(QualType DstType,
                                                QualType SrcType,
                                                SourceLocation Loc) {
   Optional<NullabilityKind> ExprNullability = SrcType->getNullability(Context);
-  if (!ExprNullability || *ExprNullability != NullabilityKind::Nullable)
+  if (!ExprNullability || (*ExprNullability != NullabilityKind::Nullable &&
+                           *ExprNullability != NullabilityKind::NullableResult))
     return;
 
   Optional<NullabilityKind> TypeNullability = DstType->getNullability(Context);
   if (!TypeNullability || *TypeNullability != NullabilityKind::NonNull)
     return;
 
   Diag(Loc, diag::warn_nullability_lost) << SrcType << DstType;
 }

clang/lib/Sema/SemaCodeComplete.cpp

if (auto nullability = AttributedType::stripOuterNullability(Type)) {
 
       case NullabilityKind::Nullable:
         Result += "nullable ";
         break;
 
       case NullabilityKind::Unspecified:
         Result += "null_unspecified ";
         break;
+
+      case NullabilityKind::NullableResult:
+        llvm_unreachable("Not supported as a context-sensitive keyword!");
+        break;
       }
     }
   }
   return Result;
 }
 
 /// Tries to find the most appropriate type location for an Objective-C
 /// block placeholder.

clang/lib/Sema/SemaExpr.cpp

 static QualType computeConditionalNullability(QualType ResTy, bool IsBin,
                                               QualType LHSTy, QualType RHSTy,
                                               ASTContext &Ctx) {
   if (!ResTy->isAnyPointerType())
     return ResTy;
 
   auto GetNullability = [&Ctx](QualType Ty) {
     Optional<NullabilityKind> Kind = Ty->getNullability(Ctx);
-    if (Kind)
+    if (Kind) {
+      // For our purposes, treat _Nullable_result as _Nullable.
+      if (*Kind == NullabilityKind::NullableResult)
+        return NullabilityKind::Nullable;
       return *Kind;
+    }
     return NullabilityKind::Unspecified;
   };
 
   auto LHSKind = GetNullability(LHSTy), RHSKind = GetNullability(RHSTy);
   NullabilityKind MergedKind;
 
   // Compute nullability of a binary conditional expression.
   if (IsBin) {

clang/lib/Sema/SemaExprObjC.cpp

QualType Sema::getMessageSendResultType(const Expr *Receiver,
 
   // There is nothing left to do if the result type cannot have a nullability
   // specifier.
   if (!resultType->canHaveNullability())
     return resultType;
 
   // Map the nullability of the result into a table index.
   unsigned receiverNullabilityIdx = 0;
-  if (auto nullability = ReceiverType->getNullability(Context))
+  if (Optional<NullabilityKind> nullability =
+          ReceiverType->getNullability(Context)) {
+    if (*nullability == NullabilityKind::NullableResult)
+      nullability = NullabilityKind::Nullable;
     receiverNullabilityIdx = 1 + static_cast<unsigned>(*nullability);
+  }
 
   unsigned resultNullabilityIdx = 0;
-  if (auto nullability = resultType->getNullability(Context))
+  if (Optional<NullabilityKind> nullability =
+          resultType->getNullability(Context)) {
+    if (*nullability == NullabilityKind::NullableResult)
+      nullability = NullabilityKind::Nullable;
     resultNullabilityIdx = 1 + static_cast<unsigned>(*nullability);
+  }
 
   // The table of nullability mappings, indexed by the receiver's nullability
   // and then the result type's nullability.
   static const uint8_t None = 0;
   static const uint8_t NonNull = 1;
   static const uint8_t Nullable = 2;
   static const uint8_t Unspecified = 3;
   static const uint8_t nullabilityMap[4][4] = {

clang/lib/Sema/SemaType.cpp

#define MS_TYPE_ATTRS_CASELIST                                                 \
   case ParsedAttr::AT_Ptr64:                                                   \
   case ParsedAttr::AT_SPtr:                                                    \
   case ParsedAttr::AT_UPtr
 
 // Nullability qualifiers.
 #define NULLABILITY_TYPE_ATTRS_CASELIST                                        \
   case ParsedAttr::AT_TypeNonNull:                                             \
   case ParsedAttr::AT_TypeNullable:                                            \
+  case ParsedAttr::AT_TypeNullableResult:                                      \
   case ParsedAttr::AT_TypeNullUnspecified
 
 namespace {
   /// An object which stores processing state for the entire
   /// GetTypeForDeclarator process.
   class TypeProcessingState {
     Sema &sema;
 
if (!Ident__Nonnull)
       Ident__Nonnull = PP.getIdentifierInfo("_Nonnull");
     return Ident__Nonnull;
 
   case NullabilityKind::Nullable:
     if (!Ident__Nullable)
       Ident__Nullable = PP.getIdentifierInfo("_Nullable");
     return Ident__Nullable;
 
+  case NullabilityKind::NullableResult:
+    if (!Ident__Nullable_result)
+      Ident__Nullable_result = PP.getIdentifierInfo("_Nullable_result");
+    return Ident__Nullable_result;
+
   case NullabilityKind::Unspecified:
     if (!Ident__Null_unspecified)
       Ident__Null_unspecified = PP.getIdentifierInfo("_Null_unspecified");
     return Ident__Null_unspecified;
   }
   llvm_unreachable("Unknown nullability kind.");
 }
 
 /// Retrieve the identifier "NSError".
 IdentifierInfo *Sema::getNSErrorIdent() {
   if (!Ident_NSError)
     Ident_NSError = PP.getIdentifierInfo("NSError");
 
   return Ident_NSError;
 }
 
 /// Check whether there is a nullability attribute of any kind in the given
 /// attribute list.
 static bool hasNullabilityAttr(const ParsedAttributesView &attrs) {
   for (const ParsedAttr &AL : attrs) {
     if (AL.getKind() == ParsedAttr::AT_TypeNonNull ||
         AL.getKind() == ParsedAttr::AT_TypeNullable ||
+        AL.getKind() == ParsedAttr::AT_TypeNullableResult ||
         AL.getKind() == ParsedAttr::AT_TypeNullUnspecified)
       return true;
   }
 
   return false;
 }
 
 namespace {
static Attr *createNullabilityAttr(ASTContext &Ctx, ParsedAttr &Attr,
                                    NullabilityKind NK) {
   switch (NK) {
   case NullabilityKind::NonNull:
     return createSimpleAttr<TypeNonNullAttr>(Ctx, Attr);
 
   case NullabilityKind::Nullable:
     return createSimpleAttr<TypeNullableAttr>(Ctx, Attr);
 
+  case NullabilityKind::NullableResult:
+    return createSimpleAttr<TypeNullableResultAttr>(Ctx, Attr);
+
   case NullabilityKind::Unspecified:
     return createSimpleAttr<TypeNullUnspecifiedAttr>(Ctx, Attr);
   }
   llvm_unreachable("unknown NullabilityKind");
 }
 
 // Diagnose whether this is a case with the multiple addr spaces.
 // Returns true if this is an invalid case.

 static NullabilityKind mapNullabilityAttrKind(ParsedAttr::Kind kind) {
   switch (kind) {
   case ParsedAttr::AT_TypeNonNull:
     return NullabilityKind::NonNull;
 
   case ParsedAttr::AT_TypeNullable:
     return NullabilityKind::Nullable;
 
+  case ParsedAttr::AT_TypeNullableResult:
+    return NullabilityKind::NullableResult;
+
   case ParsedAttr::AT_TypeNullUnspecified:
     return NullabilityKind::Unspecified;
 
   default:
     llvm_unreachable("not a nullability attribute kind");
   }
 }
 

clang/test/Index/nullability.c

 int *a;
 int * _Nonnull b;
 int * _Nullable c;
 int * _Null_unspecified d;
+int * _Nullable_result e;
 
 // RUN: env CINDEXTEST_INCLUDE_ATTRIBUTED_TYPES=1 c-index-test -test-print-type %s | FileCheck %s
 // CHECK: VarDecl=a:1:6 [type=int *] [typekind=Pointer] [isPOD=1] [pointeetype=int] [pointeekind=Int]
 // CHECK: VarDecl=b:2:16 [type=int * _Nonnull] [typekind=Attributed] [nullability=nonnull] [canonicaltype=int *] [canonicaltypekind=Pointer] [modifiedtype=int *] [modifiedtypekind=Pointer] [isPOD=1]
 // CHECK: VarDecl=c:3:17 [type=int * _Nullable] [typekind=Attributed] [nullability=nullable] [canonicaltype=int *] [canonicaltypekind=Pointer] [modifiedtype=int *] [modifiedtypekind=Pointer] [isPOD=1]
 // CHECK: VarDecl=d:4:25 [type=int * _Null_unspecified] [typekind=Attributed] [nullability=unspecified] [canonicaltype=int *] [canonicaltypekind=Pointer] [modifiedtype=int *] [modifiedtypekind=Pointer] [isPOD=1]
+// CHECK: VarDecl=e:5:24 [type=int * _Nullable_result] [typekind=Attributed] [nullability=nullable_result] [canonicaltype=int *] [canonicaltypekind=Pointer] [modifiedtype=int *] [modifiedtypekind=Pointer] [isPOD=1]

clang/test/SemaObjC/nullability.m

 @end
 
 // Checking merging of nullability when sending a message.
 @interface NSMergeReceiver
 - (id)returnsNone;
 - (nonnull id)returnsNonNull;
 - (nullable id)returnsNullable;
 - (null_unspecified id)returnsNullUnspecified;
+- (_Nullable_result id)returnsNullableResult;
 @end
 
 void test_receiver_merge(NSMergeReceiver *none,
                          _Nonnull NSMergeReceiver *nonnull,
                          _Nullable NSMergeReceiver *nullable,
+                         _Nullable_result NSMergeReceiver *nullable_result,
                          _Null_unspecified NSMergeReceiver *null_unspecified) {
   int *ptr;
 
   ptr = [nullable returnsNullable]; // expected-warning{{'id _Nullable'}}
   ptr = [nullable returnsNullUnspecified]; // expected-warning{{'id _Nullable'}}
   ptr = [nullable returnsNonNull]; // expected-warning{{'id _Nullable'}}
   ptr = [nullable returnsNone]; // expected-warning{{'id _Nullable'}}
 
+  ptr = [nullable_result returnsNullable]; // expected-warning{{'id _Nullable'}}
+  ptr = [nullable_result returnsNullUnspecified]; // expected-warning{{'id _Nullable'}}
+  ptr = [nullable_result returnsNonNull]; // expected-warning{{'id _Nullable'}}
+  ptr = [nullable_result returnsNone]; // expected-warning{{'id _Nullable'}}
+  ptr = [nullable_result returnsNullableResult]; // expected-warning{{'id _Nullable_result'}}
+
   ptr = [null_unspecified returnsNullable]; // expected-warning{{'id _Nullable'}}
   ptr = [null_unspecified returnsNullUnspecified]; // expected-warning{{'id _Null_unspecified'}}
   ptr = [null_unspecified returnsNonNull]; // expected-warning{{'id _Null_unspecified'}}
   ptr = [null_unspecified returnsNone]; // expected-warning{{'id'}}
 
   ptr = [nonnull returnsNullable]; // expected-warning{{'id _Nullable'}}
   ptr = [nonnull returnsNullUnspecified]; // expected-warning{{'id _Null_unspecified'}}
   ptr = [nonnull returnsNonNull]; // expected-warning{{'id _Nonnull'}}

 }
 
 // Check nullability of conditional expressions.
 void conditional_expr(int c) {
   NSFoo * _Nonnull p;
   NSFoo * _Nonnull nonnullP;
   NSFoo * _Nullable nullableP;
   NSFoo * _Null_unspecified unspecifiedP;
+  NSFoo * _Nullable_result nullableResultP;
   NSFoo *noneP;
 
   p = c ? nonnullP : nonnullP;
   p = c ? nonnullP : nullableP; // expected-warning{{implicit conversion from nullable pointer 'NSFoo * _Nullable' to non-nullable pointer type 'NSFoo * _Nonnull'}}
   p = c ? nonnullP : unspecifiedP;
   p = c ? nonnullP : noneP;
   p = c ? nullableP : nonnullP; // expected-warning{{implicit conversion from nullable pointer 'NSFoo * _Nullable' to non-nullable pointer type 'NSFoo * _Nonnull'}}
   p = c ? nullableP : nullableP; // expected-warning{{implicit conversion from nullable pointer 'NSFoo * _Nullable' to non-nullable pointer type 'NSFoo * _Nonnull'}}
   p = c ? nullableP : unspecifiedP; // expected-warning{{implicit conversion from nullable pointer 'NSFoo * _Nullable' to non-nullable pointer type 'NSFoo * _Nonnull'}}
   p = c ? nullableP : noneP; // expected-warning{{implicit conversion from nullable pointer 'NSFoo * _Nullable' to non-nullable pointer type 'NSFoo * _Nonnull'}}
   p = c ? unspecifiedP : nonnullP;
   p = c ? unspecifiedP : nullableP; // expected-warning{{implicit conversion from nullable pointer 'NSFoo * _Nullable' to non-nullable pointer type 'NSFoo * _Nonnull'}}
   p = c ? unspecifiedP : unspecifiedP;
   p = c ? unspecifiedP : noneP;
   p = c ? noneP : nonnullP;
   p = c ? noneP : nullableP; // expected-warning{{implicit conversion from nullable pointer 'NSFoo * _Nullable' to non-nullable pointer type 'NSFoo * _Nonnull'}}
   p = c ? noneP : unspecifiedP;
   p = c ? noneP : noneP;
+  p = c ? noneP : nullableResultP; // expected-warning{{implicit conversion from nullable pointer 'NSFoo * _Nullable' to non-nullable pointer type 'NSFoo * _Nonnull'}}
+  p = c ? nonnullP : nullableResultP; // expected-warning{{implicit conversion from nullable pointer 'NSFoo * _Nullable' to non-nullable pointer type 'NSFoo * _Nonnull'}}
+  p = c ? nullableP : nullableResultP; // expected-warning{{implicit conversion from nullable pointer 'NSFoo * _Nullable' to non-nullable pointer type 'NSFoo * _Nonnull'}}
+  p = c ? nullableResultP : nullableResultP; // expected-warning{{implicit conversion from nullable pointer 'NSFoo * _Nullable_result' to non-nullable pointer type 'NSFoo * _Nonnull'}}
 }
 
 typedef int INTS[4];
 @interface ArraysInMethods
 - (void)simple:(int [_Nonnull 2])x;
 - (void)nested:(void *_Nullable [_Nonnull 2])x;
 - (void)nestedBad:(int [2][_Nonnull 2])x; // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'int [2]'}}
 

clang/test/SemaObjC/nullable-result.m

+// RUN: %clang_cc1                 -verify -fsyntax-only -fblocks -Wnullable-to-nonnull-conversion %s
+// RUN: %clang_cc1 -xobjective-c++ -verify -fsyntax-only -fblocks -Wnullable-to-nonnull-conversion %s
+
+@class X;
+@class NSError;
+
+_Static_assert(__has_feature(nullability_nullable_result), "");
+
+@interface SomeClass
+-(void)async_get:(void (^)(X *_Nullable_result rptr, NSError *err))completionHandler;
+@end
+
+void call(SomeClass *sc) {
+  [sc async_get:^(X *_Nullable_result rptr, NSError *err) {}];
+  [sc async_get:^(X *_Nullable rptr, NSError *err) {}];
+}
+
+void test_conversion() {
+  X *_Nullable_result nr;
+  X *_Nonnull l = nr; // expected-warning{{implicit conversion from nullable pointer 'X * _Nullable_result' to non-nullable pointer type 'X * _Nonnull'}}
+
+  (void)^(X * _Nullable_result p) {
+    X *_Nonnull l = p; // expected-warning{{implicit conversion from nullable pointer 'X * _Nullable_result' to non-nullable pointer type 'X * _Nonnull'}}
+  };
+}
+
+void test_dup() {
+  id _Nullable_result _Nullable_result a; // expected-warning {{duplicate nullability specifier _Nullable_result}}
+  id _Nullable _Nullable_result b; // expected-error{{nullability specifier _Nullable_result conflicts with existing specifier '_Nullable'}}
+  id _Nullable_result _Nonnull c; // expected-error{{nullability specifier '_Nonnull' conflicts with existing specifier _Nullable_result}}
+}
+
+@interface NoContextSensitive
+-(nullable_result id)m; // expected-error {{expected a type}}
+@property(assign, nullable_result) id p; // expected-error{{unknown property attribute 'nullable_result'}}
+@end

clang/tools/c-index-test/c-index-test.c

static void PrintTypeTemplateArgs(CXType T, const char *Format) {
   }
 }
 
 static void PrintNullabilityKind(CXType T, const char *Format) {
   enum CXTypeNullabilityKind N = clang_Type_getNullability(T);
 
   const char *nullability = 0;
   switch (N) {
-    case CXTypeNullability_NonNull: nullability = "nonnull"; break;
-    case CXTypeNullability_Nullable: nullability = "nullable"; break;
-    case CXTypeNullability_Unspecified: nullability = "unspecified"; break;
-    case CXTypeNullability_Invalid: break;
+  case CXTypeNullability_NonNull:
+    nullability = "nonnull";
+    break;
+  case CXTypeNullability_Nullable:
+    nullability = "nullable";
+    break;
+  case CXTypeNullability_NullableResult:
+    nullability = "nullable_result";
+    break;
+  case CXTypeNullability_Unspecified:
+    nullability = "unspecified";
+    break;
+  case CXTypeNullability_Invalid:
+    break;
   }
 
   if (nullability) {
     printf(Format, nullability);
   }
 }
 
 static enum CXChildVisitResult PrintType(CXCursor cursor, CXCursor p,

clang/tools/libclang/CXType.cpp

enum CXTypeNullabilityKind clang_Type_getNullability(CXType CT) {
 
   ASTContext &Ctx = cxtu::getASTUnit(GetTU(CT))->getASTContext();
   if (auto nullability = T->getNullability(Ctx)) {
     switch (*nullability) {
       case NullabilityKind::NonNull:
         return CXTypeNullability_NonNull;
       case NullabilityKind::Nullable:
         return CXTypeNullability_Nullable;
+      case NullabilityKind::NullableResult:
+        return CXTypeNullability_NullableResult;
       case NullabilityKind::Unspecified:
         return CXTypeNullability_Unspecified;
     }
   }
   return CXTypeNullability_Invalid;
 }
 
 CXType clang_Type_getValueType(CXType CT) {
   QualType T = GetQualType(CT);
 
   if (T.isNull() || !T->isAtomicType())
       return MakeCXType(QualType(), GetTU(CT));
 
   const auto *AT = T->castAs<AtomicType>();
   return MakeCXType(AT->getValueType(), GetTU(CT));
 }