[WIP] Add support for capturing all possible versioned APINotes without applying them

artemcm · artemcm · commit 7ee2b42e2f14 · 2024-10-23T14:35:21.000-07:00
Leaving it up to the client to select the appropriate version to apply
diff --git a/clang/include/clang/APINotes/APINotesManager.h b/clang/include/clang/APINotes/APINotesManager.h
@@ -54,6 +54,13 @@ class APINotesManager {
   /// source file from which an entity was declared.
   bool ImplicitAPINotes;
 
+  /// Whether to apply all APINotes as optionally-applied versioned
+  /// entities. This means that when building a Clang module,
+  /// we capture every note on a given decl wrapped in a SwiftVersionedAttr
+  /// (with an empty version field for unversioned notes), and have the
+  /// client apply the relevant version's notes.
+  bool VersionIndependentSwift;
+
   /// The Swift version to use when interpreting versioned API notes.
   llvm::VersionTuple SwiftVersion;
 
@@ -159,6 +166,8 @@ class APINotesManager {
 
   /// Find the API notes readers that correspond to the given source location.
   llvm::SmallVector<APINotesReader *, 2> findAPINotes(SourceLocation Loc);
+
+  bool captureVersionIndependentSwift() { return VersionIndependentSwift; }
 };
 
 } // end namespace api_notes
diff --git a/clang/include/clang/Basic/Attr.td b/clang/include/clang/Basic/Attr.td
@@ -2523,6 +2523,26 @@ def SwiftVersionedRemoval : Attr {
   }];
 }
 
+def SwiftType : Attr {
+  // This attribute has no spellings as it is only ever created implicitly
+  // from API notes.
+  let Spellings = [];
+  let Args = [StringArgument<"TypeString">];
+  let SemaHandler = 0;
+  let Documentation = [InternalOnly];
+}
+
+def SwiftNullability : Attr {
+  // This attribute has no spellings as it is only ever created implicitly
+  // from API notes.
+  let Spellings = [];
+  let Args = [EnumArgument<"Kind", "Kind",
+              ["non_null", "nullable", "unspecified", "nullable_result"],
+              ["NonNull", "Nullable", "Unspecified", "NullableResult"]>];
+  let SemaHandler = 0;
+  let Documentation = [InternalOnly];
+}
+
 def SwiftAsyncName : InheritableAttr {
   let Spellings = [GNU<"swift_async_name">];
   let Args = [StringArgument<"Name">];
diff --git a/clang/include/clang/Basic/LangOptions.def b/clang/include/clang/Basic/LangOptions.def
@@ -410,6 +410,7 @@ LANGOPT(XLPragmaPack, 1, 0, "IBM XL #pragma pack handling")
 LANGOPT(RetainCommentsFromSystemHeaders, 1, 0, "retain documentation comments from system headers in the AST")
 LANGOPT(APINotes, 1, 0, "use external API notes")
 LANGOPT(APINotesModules, 1, 0, "use external API notes")
+LANGOPT(SwiftVersionIndependentAPINotes, 1, 0, "use external API notes capturing all versions")
 LANGOPT(NeededByPCHOrCompilationUsesPCH, 1, 0, "compilation involves pch")
 
 LANGOPT(SanitizeAddressFieldPadding, 2, 0, "controls how aggressive is ASan "
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
@@ -1520,6 +1520,11 @@ defm apinotes_modules : BoolOption<"f", "apinotes-modules",
   PosFlag<SetTrue, [], "Enable">, NegFlag<SetFalse, [], "Disable">,
   BothFlags<[CC1Option], " module-based external API notes support">>,
   Group<f_clang_Group>;
+defm swift_version_independent_apinotes : BoolOption<"f", "swift-version-independent-apinotes",
+  LangOpts<"SwiftVersionIndependentAPINotes">, DefaultFalse,
+  PosFlag<SetTrue, [], "Enable">, NegFlag<SetFalse, [], "Disable">,
+  BothFlags<[CC1Option], " version-independent external API notes support">>,
+  Group<f_clang_Group>;
 def fapinotes_cache_path : Joined<["-"], "fapinotes-cache-path=">,
   Group<i_Group>, Flags<[NoXarchOption]>, MetaVarName<"<directory>">,
   HelpText<"Does nothing; API notes are no longer cached separately from modules">;
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
@@ -4750,6 +4750,15 @@ class Sema final {
   ///
   /// Triggered by declaration-attribute processing.
   void ProcessAPINotes(Decl *D);
+  void ApplyNullability(Decl *D, NullabilityKind Nullability);
+  void ApplyAPINotesType(Decl *D, StringRef TypeString);
+
+  /// Whether APINotes should be gathered for all
+  /// applicable Swift versions, without being applied. Leaving
+  /// clients of the current module to apply the correct version.
+  bool captureSwiftVersionIndependentAPINotes() {
+    return APINotes.captureVersionIndependentSwift();
+  }
 
   /// Determine if type T is a valid subject for a nonnull and similar
   /// attributes. By default, we look through references (the behavior used by
diff --git a/clang/lib/APINotes/APINotesManager.cpp b/clang/lib/APINotes/APINotesManager.cpp
@@ -65,7 +65,8 @@ namespace {
 
 APINotesManager::APINotesManager(SourceManager &sourceMgr,
                                  const LangOptions &langOpts)
-  : SourceMgr(sourceMgr), ImplicitAPINotes(langOpts.APINotes) { }
+  : SourceMgr(sourceMgr), ImplicitAPINotes(langOpts.APINotes),
+    VersionIndependentSwift(langOpts.SwiftVersionIndependentAPINotes) { }
 
 APINotesManager::~APINotesManager() {
   // Free the API notes readers.
diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -6823,6 +6823,10 @@ void Clang::ConstructJob(Compilation &C, const JobAction &Job,
     Args.AddLastArg(CmdArgs, options::OPT_fapinotes_swift_version);
   }
 
+  if (Args.hasFlag(options::OPT_fswift_version_independent_apinotes,
+                   options::OPT_fno_swift_version_independent_apinotes, false))
+    CmdArgs.push_back("-fswift-version-independent-apinotes");
+
   // -fblocks=0 is default.
   if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
                    TC.IsBlocksDefault()) ||
diff --git a/clang/lib/Sema/SemaAPINotes.cpp b/clang/lib/Sema/SemaAPINotes.cpp
@@ -51,75 +51,57 @@ static bool isMultiLevelPointerType(QualType type) {
          pointee->isMemberPointerType();
 }
 
-// Apply nullability to the given declaration.
-static void applyNullability(Sema &S, Decl *decl, NullabilityKind nullability,
-                             VersionedInfoMetadata metadata) {
-  if (!metadata.IsActive)
+static void applyAPINotesType(Sema &S, Decl *decl, StringRef typeString,
+                              VersionedInfoMetadata metadata) {
+  if (typeString.empty())
     return;
 
-  QualType type;
-
-  // Nullability for a function/method appertains to the retain type.
-  if (auto function = dyn_cast<FunctionDecl>(decl)) {
-    type = function->getReturnType();
-  } else if (auto method = dyn_cast<ObjCMethodDecl>(decl)) {
-    type = method->getReturnType();
-  } else if (auto value = dyn_cast<ValueDecl>(decl)) {
-    type = value->getType();
-  } else if (auto property = dyn_cast<ObjCPropertyDecl>(decl)) {
-    type = property->getType();
+  // Version-independent APINotes add "type" annotations
+  // with a versioned attribute for the client to select and apply.
+  if (S.captureSwiftVersionIndependentAPINotes()) {
+    auto *typeAttr = SwiftTypeAttr::CreateImplicit(
+        S.Context, typeString);
+    auto *versioned = SwiftVersionedAttr::CreateImplicit(
+        S.Context, metadata.Version, typeAttr, metadata.IsReplacement);
+    decl->addAttr(versioned);
   } else {
-    return;
+    if (!metadata.IsActive)
+      return;
+    S.ApplyAPINotesType(decl, typeString);
   }
+}
 
-  // Check the nullability specifier on this type.
-  QualType origType = type;
-  S.checkImplicitNullabilityTypeSpecifier(type, nullability,
-                                          decl->getLocation(),
-                                          isa<ParmVarDecl>(decl),
-                                          /*overrideExisting=*/true);
-  if (type.getTypePtr() == origType.getTypePtr())
-    return;
-
-  if (auto function = dyn_cast<FunctionDecl>(decl)) {
-    const FunctionType *fnType = function->getType()->castAs<FunctionType>();
-    if (const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(fnType)) {
-      function->setType(S.Context.getFunctionType(type, proto->getParamTypes(),
-                                                  proto->getExtProtoInfo()));
-    } else {
-      function->setType(S.Context.getFunctionNoProtoType(type,
-                                                         fnType->getExtInfo()));
-    }
-  } else if (auto method = dyn_cast<ObjCMethodDecl>(decl)) {
-    method->setReturnType(type);
-
-    // Make it a context-sensitive keyword if we can.
-    if (!isMultiLevelPointerType(type)) {
-      method->setObjCDeclQualifier(
-        Decl::ObjCDeclQualifier(method->getObjCDeclQualifier() |
-                                Decl::OBJC_TQ_CSNullability));
-    }
-  } else if (auto value = dyn_cast<ValueDecl>(decl)) {
-    value->setType(type);
-
-    // Make it a context-sensitive keyword if we can.
-    if (auto parm = dyn_cast<ParmVarDecl>(decl)) {
-      if (parm->isObjCMethodParameter() && !isMultiLevelPointerType(type)) {
-        parm->setObjCDeclQualifier(
-          Decl::ObjCDeclQualifier(parm->getObjCDeclQualifier() |
-                                  Decl::OBJC_TQ_CSNullability));
-      }
-    }
-  } else if (auto property = dyn_cast<ObjCPropertyDecl>(decl)) {
-    property->setType(type, property->getTypeSourceInfo());
-
-    // Make it a property attribute if we can.
-    if (!isMultiLevelPointerType(type)) {
-      property->setPropertyAttributes(
-        ObjCPropertyAttribute::kind_null_resettable);
+static void applyNullability(Sema &S, Decl *decl, NullabilityKind nullability,
+                             VersionedInfoMetadata metadata) {
+  // Version-independent APINotes add "nullability" annotations
+  // with a versioned attribute for the client to select and apply.
+  if (S.captureSwiftVersionIndependentAPINotes()) {
+    SwiftNullabilityAttr::Kind attrNullabilityKind;
+    switch (nullability) {
+      case NullabilityKind::NonNull:
+        attrNullabilityKind = SwiftNullabilityAttr::Kind::NonNull;
+        break;
+      case NullabilityKind::Nullable:
+        attrNullabilityKind = SwiftNullabilityAttr::Kind::Nullable;
+        break;
+      case NullabilityKind::Unspecified:
+        attrNullabilityKind = SwiftNullabilityAttr::Kind::Unspecified;
+        break;
+      case NullabilityKind::NullableResult:
+        attrNullabilityKind = SwiftNullabilityAttr::Kind::NullableResult;
+        break;
     }
+    auto *nullabilityAttr = SwiftNullabilityAttr::CreateImplicit(
+        S.Context, attrNullabilityKind);
+    auto *versioned = SwiftVersionedAttr::CreateImplicit(
+        S.Context, metadata.Version, nullabilityAttr, metadata.IsReplacement);
+    decl->addAttr(versioned);
+    return;
   } else {
-    llvm_unreachable("cannot handle nullability here");
+    if (!metadata.IsActive)
+      return;
+
+    S.ApplyNullability(decl, nullability);
   }
 }
 
@@ -376,37 +358,33 @@ static bool checkAPINotesReplacementType(Sema &S, SourceLocation loc,
   return false;
 }
 
-/// Process API notes for a variable or property.
-static void ProcessAPINotes(Sema &S, Decl *D,
-                            const api_notes::VariableInfo &info,
-                            VersionedInfoMetadata metadata) {
-  // Type override.
-  if (metadata.IsActive && !info.getType().empty() &&
-      S.ParseTypeFromStringCallback) {
-    auto parsedType = S.ParseTypeFromStringCallback(info.getType(),
-                                                    "<API Notes>",
-                                                    D->getLocation());
+void Sema::ApplyAPINotesType(Decl *D, StringRef TypeString) {
+  if (!TypeString.empty() &&
+      ParseTypeFromStringCallback) {
+    auto parsedType = ParseTypeFromStringCallback(TypeString,
+                                                  "<API Notes>",
+                                                  D->getLocation());
     if (parsedType.isUsable()) {
       QualType type = Sema::GetTypeFromParser(parsedType.get());
       auto typeInfo =
-        S.Context.getTrivialTypeSourceInfo(type, D->getLocation());
+      Context.getTrivialTypeSourceInfo(type, D->getLocation());
 
       if (auto var = dyn_cast<VarDecl>(D)) {
         // Make adjustments to parameter types.
         if (isa<ParmVarDecl>(var)) {
-          type = S.adjustParameterTypeForObjCAutoRefCount(type,
-                                                          D->getLocation(),
-                                                          typeInfo);
-          type = S.Context.getAdjustedParameterType(type);
+          type = adjustParameterTypeForObjCAutoRefCount(type,
+                                                        D->getLocation(),
+                                                        typeInfo);
+          type = Context.getAdjustedParameterType(type);
         }
 
-        if (!checkAPINotesReplacementType(S, var->getLocation(), var->getType(),
+        if (!checkAPINotesReplacementType(*this, var->getLocation(), var->getType(),
                                           type)) {
           var->setType(type);
           var->setTypeSourceInfo(typeInfo);
         }
       } else if (auto property = dyn_cast<ObjCPropertyDecl>(D)) {
-        if (!checkAPINotesReplacementType(S, property->getLocation(),
+        if (!checkAPINotesReplacementType(*this, property->getLocation(),
                                           property->getType(),
                                           type)) {
           property->setType(type, typeInfo);
@@ -416,6 +394,83 @@ static void ProcessAPINotes(Sema &S, Decl *D,
       }
     }
   }
+}
+
+// Apply nullability to the given declaration.
+void Sema::ApplyNullability(Decl *Decl, NullabilityKind Nullability) {
+  QualType type;
+
+  // Nullability for a function/method appertains to the retain type.
+  if (auto function = dyn_cast<FunctionDecl>(Decl)) {
+    type = function->getReturnType();
+  } else if (auto method = dyn_cast<ObjCMethodDecl>(Decl)) {
+    type = method->getReturnType();
+  } else if (auto value = dyn_cast<ValueDecl>(Decl)) {
+    type = value->getType();
+  } else if (auto property = dyn_cast<ObjCPropertyDecl>(Decl)) {
+    type = property->getType();
+  } else {
+    return;
+  }
+
+  // Check the nullability specifier on this type.
+  QualType origType = type;
+  checkImplicitNullabilityTypeSpecifier(type, Nullability,
+                                        Decl->getLocation(),
+                                        isa<ParmVarDecl>(Decl),
+                                        /*overrideExisting=*/true);
+  if (type.getTypePtr() == origType.getTypePtr())
+    return;
+
+  if (auto function = dyn_cast<FunctionDecl>(Decl)) {
+    const FunctionType *fnType = function->getType()->castAs<FunctionType>();
+    if (const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(fnType)) {
+      function->setType(Context.getFunctionType(type, proto->getParamTypes(),
+                                                proto->getExtProtoInfo()));
+    } else {
+      function->setType(Context.getFunctionNoProtoType(type,
+                                                       fnType->getExtInfo()));
+    }
+  } else if (auto method = dyn_cast<ObjCMethodDecl>(Decl)) {
+    method->setReturnType(type);
+
+    // Make it a context-sensitive keyword if we can.
+    if (!isMultiLevelPointerType(type)) {
+      method->setObjCDeclQualifier(
+        Decl::ObjCDeclQualifier(method->getObjCDeclQualifier() |
+                                Decl::OBJC_TQ_CSNullability));
+    }
+  } else if (auto value = dyn_cast<ValueDecl>(Decl)) {
+    value->setType(type);
+
+    // Make it a context-sensitive keyword if we can.
+    if (auto parm = dyn_cast<ParmVarDecl>(Decl)) {
+      if (parm->isObjCMethodParameter() && !isMultiLevelPointerType(type)) {
+        parm->setObjCDeclQualifier(
+          Decl::ObjCDeclQualifier(parm->getObjCDeclQualifier() |
+                                  Decl::OBJC_TQ_CSNullability));
+      }
+    }
+  } else if (auto property = dyn_cast<ObjCPropertyDecl>(Decl)) {
+    property->setType(type, property->getTypeSourceInfo());
+
+    // Make it a property attribute if we can.
+    if (!isMultiLevelPointerType(type)) {
+      property->setPropertyAttributes(
+        ObjCPropertyAttribute::kind_null_resettable);
+    }
+  } else {
+    llvm_unreachable("cannot handle nullability here");
+  }
+}
+
+
+/// Process API notes for a variable or property.
+static void ProcessAPINotes(Sema &S, Decl *D,
+                            const api_notes::VariableInfo &info,
+                            VersionedInfoMetadata metadata) {
+  // Type override.
+  applyAPINotesType(S, D, info.getType(), metadata);
 
   // Nullability.
   if (auto Nullability = info.getNullability()) {
@@ -802,8 +857,8 @@ template <typename SpecificDecl, typename SpecificInfo>
 static void ProcessVersionedAPINotes(
     Sema &S, SpecificDecl *D,
     const api_notes::APINotesReader::VersionedInfo<SpecificInfo> Info) {
-
-  maybeAttachUnversionedSwiftName(S, D, Info);
+  if (!S.captureSwiftVersionIndependentAPINotes())
+    maybeAttachUnversionedSwiftName(S, D, Info);
 
   unsigned Selected = Info.getSelected().value_or(Info.size());
 
@@ -813,10 +868,18 @@ static void ProcessVersionedAPINotes(
     std::tie(Version, InfoSlice) = Info[i];
     auto Active = (i == Selected) ? IsActive : IsNotActive;
     auto Replacement = IsNotReplacement;
-    if (Active == IsNotActive && Version.empty()) {
+
+    // When collection all APINotes as version-independent,
+    // capture all as inactive and defer to the client select the
+    // right one.
+    if (S.captureSwiftVersionIndependentAPINotes()) {
+      Active = IsNotActive;
+      Replacement = IsNotReplacement;
+    } else if (Active == IsNotActive && Version.empty()) {
       Replacement = IsReplacement;
       Version = Info[Selected].first;
     }
+
     ProcessAPINotes(S, D, InfoSlice, VersionedInfoMetadata(Version, Active,
                                                            Replacement));
   }
