Extend availability attribute to support feature-based availability

This commit extends the `__availability` attribute to accept a feature
name and a boolean-like integer argument (0 or 1) to indicate
availability based on feature presence or absence.

`__builtin_available` and `@available` take a feature name as their
arguments. References to annotated declarations in unguarded contexts
are rejected.

For example:

```
__attribute__((availability(domain:feature1, 0)))
void available_func(void);

__attribute__((availability(domain:feature1, 1)))
void unavailable_func(void);

if (__builtin_available(feature1)) {
  available_func();
  unavailable_func(); // error
} else {
  available_func(); // error
  unavailable_func();
}
```

rdar://137999979

Author: ahatanaka

clang/include/clang/AST/ASTContext.h

@@ -25,6 +25,7 @@
 #include "clang/AST/RawCommentList.h"
 #include "clang/AST/TemplateName.h"
 #include "clang/Basic/LLVM.h"
+#include "clang/Basic/LangOptions.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/DenseMap.h"
@@ -801,6 +802,35 @@ class ASTContext : public RefCountedBase<ASTContext> {
     return DiagAllocator;
   }
 
+  struct AvailabilityDomainInfo {
+    FeatureAvailKind Kind = FeatureAvailKind::None;
+    ImplicitCastExpr *Call = nullptr;
+    bool isInvalid() const { return Kind == FeatureAvailKind::None; }
+  };
+
+  std::map<StringRef, AvailabilityDomainInfo> AvailabilityDomainMap;
+
+  void addAvailabilityDomainMap(StringRef Name, AvailabilityDomainInfo Info) {
+    AvailabilityDomainMap[Name] = Info;
+  }
+
+  std::pair<DomainAvailabilityAttr *, bool>
+  checkNewFeatureAvailability(Decl *D, StringRef DomainName, bool Unavailable);
+
+  bool hasFeatureAvailabilityAttr(const Decl *D) const;
+
+  // Retrieve availability domain information for a feature.
+  AvailabilityDomainInfo getFeatureAvailInfo(StringRef FeatureName) const;
+
+  // Retrieve feature name and availability domain information on a decl. If the
+  // decl doesn't have attribute availability_domain on it, the name will be
+  // empty and AvailabilityDomainInfo::Kind will be set to
+  // FeatureAvailKind::None.
+  std::pair<StringRef, AvailabilityDomainInfo>
+  getFeatureAvailInfo(Decl *D) const;
+
+  bool hasUnavailableFeature(const Decl *D) const;
+
   const TargetInfo &getTargetInfo() const { return *Target; }
   const TargetInfo *getAuxTargetInfo() const { return AuxTarget; }
 

clang/include/clang/AST/Availability.h

@@ -37,6 +37,8 @@ class AvailabilitySpec {
   /// Name of the platform that Version corresponds to.
   StringRef Platform;
 
+  StringRef DomainName;
+
   SourceLocation BeginLoc, EndLoc;
 
 public:
@@ -45,6 +47,9 @@ class AvailabilitySpec {
       : Version(Version), Platform(Platform), BeginLoc(BeginLoc),
         EndLoc(EndLoc) {}
 
+  AvailabilitySpec(StringRef DomainName, SourceLocation Loc)
+      : DomainName(DomainName), BeginLoc(Loc), EndLoc(Loc) {}
+
   /// This constructor is used when representing the '*' case.
   AvailabilitySpec(SourceLocation StarLoc)
       : BeginLoc(StarLoc), EndLoc(StarLoc) {}
@@ -56,6 +61,9 @@ class AvailabilitySpec {
 
   /// Returns true when this represents the '*' case.
   bool isOtherPlatformSpec() const { return Version.empty(); }
+
+  bool isDomainName() const { return !DomainName.empty(); }
+  StringRef getDomainName() const { return DomainName; }
 };
 
 class Decl;

clang/include/clang/AST/ExprObjC.h

@@ -1693,7 +1693,9 @@ class ObjCBridgedCastExpr final
 /// be used in the condition of an \c if, but it is also usable as top level
 /// expressions.
 ///
-class ObjCAvailabilityCheckExpr : public Expr {
+class ObjCAvailabilityCheckExpr final
+    : public Expr,
+      private llvm::TrailingObjects<ObjCAvailabilityCheckExpr, char> {
 public:
   struct VersionAsWritten {
     /// Platform version canonicalized for use with availability checks.
@@ -1704,21 +1706,46 @@ class ObjCAvailabilityCheckExpr : public Expr {
 
 private:
   friend class ASTStmtReader;
+  friend llvm::TrailingObjects<ObjCAvailabilityCheckExpr, char>;
 
   VersionAsWritten VersionToCheck;
   SourceLocation AtLoc, RParen;
 
+  void setHasDomainName(bool V) {
+    ObjCAvailabilityCheckExprBits.HasDomainName = V;
+  }
+
+  ObjCAvailabilityCheckExpr(SourceLocation AtLoc, SourceLocation RParen,
+                            QualType Ty, StringRef DomainName)
+      : Expr(ObjCAvailabilityCheckExprClass, Ty, VK_PRValue, OK_Ordinary),
+        VersionToCheck(), AtLoc(AtLoc), RParen(RParen) {
+    setDependence(ExprDependence::None);
+    setHasDomainName(true);
+    strcpy(getTrailingObjects<char>(), DomainName.data());
+  }
+
 public:
   ObjCAvailabilityCheckExpr(VersionAsWritten VersionToCheck,
                             SourceLocation AtLoc,
                             SourceLocation RParen, QualType Ty)
       : Expr(ObjCAvailabilityCheckExprClass, Ty, VK_PRValue, OK_Ordinary),
         VersionToCheck(VersionToCheck), AtLoc(AtLoc), RParen(RParen) {
     setDependence(ExprDependence::None);
+    setHasDomainName(false);
   }
 
+  static ObjCAvailabilityCheckExpr *
+  CreateAvailabilityFeatureCheck(SourceLocation AtLoc, SourceLocation RParen,
+                                 QualType Ty, StringRef DomainName,
+                                 const ASTContext &C);
+
   explicit ObjCAvailabilityCheckExpr(EmptyShell Shell)
-      : Expr(ObjCAvailabilityCheckExprClass, Shell) {}
+      : Expr(ObjCAvailabilityCheckExprClass, Shell) {
+    setHasDomainName(false);
+  }
+
+  static ObjCAvailabilityCheckExpr *
+  CreateEmpty(const ASTContext &C, Stmt::EmptyShell Empty, size_t FeaturesLen);
 
   SourceLocation getBeginLoc() const { return AtLoc; }
   SourceLocation getEndLoc() const { return RParen; }
@@ -1731,6 +1758,14 @@ class ObjCAvailabilityCheckExpr : public Expr {
     return VersionToCheck.SourceVersion;
   }
 
+  bool hasDomainName() const {
+    return ObjCAvailabilityCheckExprBits.HasDomainName;
+  }
+  StringRef getDomainName() const {
+    assert(hasDomainName());
+    return getTrailingObjects<char>();
+  }
+
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }

clang/include/clang/AST/Stmt.h

@@ -1226,6 +1226,15 @@ class alignas(void *) Stmt {
     unsigned ShouldCopy : 1;
   };
 
+  class ObjCAvailabilityCheckExprBitfields {
+    friend class ObjCAvailabilityCheckExpr;
+    LLVM_PREFERRED_TYPE(ExprBitfields)
+    unsigned : NumExprBits;
+
+    LLVM_PREFERRED_TYPE(bool)
+    unsigned HasDomainName : 1;
+  };
+
   //===--- Clang Extensions bitfields classes ---===//
 
   class OpaqueValueExprBitfields {
@@ -1324,6 +1333,7 @@ class alignas(void *) Stmt {
 
     // Obj-C Expressions
     ObjCIndirectCopyRestoreExprBitfields ObjCIndirectCopyRestoreExprBits;
+    ObjCAvailabilityCheckExprBitfields ObjCAvailabilityCheckExprBits;
 
     // Clang Extensions
     OpaqueValueExprBitfields OpaqueValueExprBits;

clang/include/clang/Basic/Attr.td

@@ -1124,6 +1124,25 @@ static llvm::Triple::EnvironmentType getEnvironmentType(llvm::StringRef Environm
   let Documentation = [AvailabilityDocs];
 }
 
+def DomainAvailability : InheritableAttr {
+  // This attribute has no spellings as it is created implicitly when
+  // __attribute__((availability(domain:...))) is seen.
+  let Spellings = [Clang<"">];
+  let Args = [StringArgument<"domain">, BoolArgument<"unavailable">];
+  let AdditionalMembers = [{
+    std::string getFeatureAttributeStr() const;
+  }];
+  let Documentation = [Undocumented];
+}
+
+// This attribute is used to annotate structs of type `_AvailabilityDomain`.
+def AvailabilityDomain : InheritableAttr {
+  let Spellings = [Clang<"availability_domain">];
+  let Args = [IdentifierArgument<"name">];
+  let Subjects = SubjectList<[Var]>;
+  let Documentation = [Undocumented];
+}
+
 def ExternalSourceSymbol : InheritableAttr {
   let Spellings = [Clang<"external_source_symbol", /*allowInC=*/1,
                    /*version=*/20230206>];

clang/include/clang/Basic/DiagnosticFrontendKinds.td

@@ -144,6 +144,9 @@ def err_fe_invalid_exception_model
 def err_fe_invalid_source_date_epoch : Error<
     "environment variable 'SOURCE_DATE_EPOCH' ('%0') must be a non-negative decimal integer <= %1">;
 
+def err_feature_availability_flag_invalid_value : Error<
+  "invalid value '%0' passed to '-ffeature-availability='; expected <feature>:<on|off>">;
+
 def err_fe_incompatible_option_with_remote_cache : Error<
   "'%0' is incompatible with remote caching backend">;
 def err_fe_unable_to_load_include_tree : Error<

clang/include/clang/Basic/DiagnosticParseKinds.td

@@ -1122,6 +1122,11 @@ def err_availability_expected_platform : Error<
 def err_availability_expected_environment : Error<
   "expected an environment name, e.g., 'compute'">;
 
+def err_features_domain_name : Error<
+  "expected a domain name">;
+def err_feature_invalid_availability_check : Error<
+  "cannot pass a domain argument along with other arguments">;
+
 // objc_bridge_related attribute
 def err_objcbridge_related_expected_related_class : Error<
   "expected a related Objective-C class name, e.g., 'NSColor'">;

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -3960,6 +3960,28 @@ def err_availability_unexpected_parameter: Error<
 def warn_unguarded_availability :
   Warning<"%0 is only available %select{|in %4 environment }3on %1 %2 or newer">,
   InGroup<UnguardedAvailability>, DefaultIgnore;
+def err_unguarded_feature : Error<
+  "use of %0 requires feature '%1' to be %select{available|unavailable}2">;
+def err_label_in_conditionally_guarded_feature : Error<
+  "labels cannot appear in regions conditionally guarded by features">;
+def err_features_invalid_for_decl : Error<
+  "feature attributes cannot be applied to %0">;
+def err_features_invalid_name : Error<
+  "cannot find definition of feature attribute '%0'">;
+def err_features_invalid__arg : Error<
+  "invalid argument %0: must evaluate to 0 or 1">;
+def err_feature_invalid_for_decl : Error<
+  "feature attribute '%0(%1)' cannot be applied to this decl">;
+def err_feature_merge_incompatible : Error<
+  "cannot merge incompatible feature attribute to this decl">;
+def err_new_feature_redeclaration : Error<
+  "new feature attributes cannot be added to redeclarations">;
+def err_feature_invalid_added : Error<
+  "cannot add feature availability to this decl">;
+def note_feature_incompatible0 : Note<
+  "feature attribute %0">;
+def note_feature_incompatible1 : Note<
+  "is incompatible with %0">;
 def warn_unguarded_availability_unavailable :
   Warning<"%0 is unavailable">,
   InGroup<UnguardedAvailability>, DefaultIgnore;

clang/include/clang/Basic/LangOptions.h

@@ -64,6 +64,8 @@ enum class PointerAuthenticationMode : unsigned {
   SignAndAuth
 };
 
+enum class FeatureAvailKind { None, Available, Unavailable, Dynamic };
+
 /// Bitfields of LangOptions, split out from LangOptions in order to ensure that
 /// this large collection of bitfields is a trivial class type.
 class LangOptionsBase {
@@ -544,6 +546,8 @@ class LangOptions : public LangOptionsBase {
   /// This list is sorted.
   std::vector<std::string> ModuleFeatures;
 
+  std::vector<std::string> FeatureAvailability;
+
   /// Options for parsing comments.
   CommentOptions CommentOpts;
 
@@ -561,6 +565,16 @@ class LangOptions : public LangOptionsBase {
   /// host code generation.
   std::string OMPHostIRFile;
 
+  llvm::StringMap<FeatureAvailKind> FeatureAvailabilityMap;
+
+  void setFeatureAvailability(StringRef Feature, FeatureAvailKind Kind) {
+    FeatureAvailabilityMap[Feature] = Kind;
+  }
+
+  FeatureAvailKind getFeatureAvailability(StringRef Feature) const {
+    return FeatureAvailabilityMap.lookup(Feature);
+  }
+
   /// The user provided compilation unit ID, if non-empty. This is used to
   /// externalize static variables which is needed to support accessing static
   /// device variables in host code for single source offloading languages

clang/include/clang/Driver/Options.td

@@ -3433,6 +3433,10 @@ def fno_builtin : Flag<["-"], "fno-builtin">, Group<f_Group>,
 def fno_builtin_ : Joined<["-"], "fno-builtin-">, Group<f_Group>,
   Visibility<[ClangOption, CC1Option, CLOption, DXCOption]>,
   HelpText<"Disable implicit builtin knowledge of a specific function">;
+def ffeature_availability_EQ : Joined<["-"], "ffeature-availability=">, Group<f_Group>,
+  Visibility<[CC1Option]>,
+  HelpText<"feature availability">,
+  MarshallingInfoStringVector<LangOpts<"FeatureAvailability">>;
 def fno_common : Flag<["-"], "fno-common">, Group<f_Group>,
   Visibility<[ClangOption, CC1Option]>,
     HelpText<"Compile common globals like normal definitions">;

clang/include/clang/Parse/Parser.h

@@ -3127,6 +3127,12 @@ class Parser : public CodeCompletionHandler {
   void ParseHLSLQualifiers(ParsedAttributes &Attrs);
 
   VersionTuple ParseVersionTuple(SourceRange &Range);
+  void ParseFeatureAvailabilityAttribute(
+      IdentifierInfo &Availability, SourceLocation AvailabilityLoc,
+      ParsedAttributes &attrs, SourceLocation *endLoc,
+      IdentifierInfo *ScopeName, SourceLocation ScopeLoc, ParsedAttr::Form Form,
+      BalancedDelimiterTracker &T);
+
   void ParseAvailabilityAttribute(IdentifierInfo &Availability,
                                   SourceLocation AvailabilityLoc,
                                   ParsedAttributes &attrs,

clang/include/clang/Sema/DelayedDiagnostic.h

@@ -125,7 +125,12 @@ class AccessedEntity {
 /// the complete parsing of the current declaration.
 class DelayedDiagnostic {
 public:
-  enum DDKind : unsigned char { Availability, Access, ForbiddenType };
+  enum DDKind : unsigned char {
+    Availability,
+    FeatureAvailability,
+    Access,
+    ForbiddenType
+  };
 
   DDKind Kind;
   bool Triggered;
@@ -143,6 +148,9 @@ class DelayedDiagnostic {
                                             StringRef Msg,
                                             bool ObjCPropertyAccess);
 
+  static DelayedDiagnostic
+  makeFeatureAvailability(NamedDecl *D, ArrayRef<SourceLocation> Locs);
+
   static DelayedDiagnostic makeAccess(SourceLocation Loc,
                                       const AccessedEntity &Entity) {
     DelayedDiagnostic DD;
@@ -201,6 +209,12 @@ class DelayedDiagnostic {
     return AvailabilityData.AR;
   }
 
+  const NamedDecl *getFeatureAvailabilityDecl() const {
+    assert(Kind == FeatureAvailability &&
+           "Not a feature availability diagnostic.");
+    return FeatureAvailabilityData.Decl;
+  }
+
   /// The diagnostic ID to emit.  Used like so:
   ///   Diag(diag.Loc, diag.getForbiddenTypeDiagnostic())
   ///     << diag.getForbiddenTypeOperand()
@@ -246,6 +260,10 @@ class DelayedDiagnostic {
     bool ObjCPropertyAccess;
   };
 
+  struct FAD {
+    const NamedDecl *Decl;
+  };
+
   struct FTD {
     unsigned Diagnostic;
     unsigned Argument;
@@ -254,6 +272,7 @@ class DelayedDiagnostic {
 
   union {
     struct AD AvailabilityData;
+    struct FAD FeatureAvailabilityData;
     struct FTD ForbiddenTypeData;
 
     /// Access control.

clang/include/clang/Sema/ParsedAttr.h

@@ -363,6 +363,8 @@ class ParsedAttr final
     return IsProperty;
   }
 
+  bool isAvailabilityAttribute() const { return IsAvailability; }
+
   bool isInvalid() const { return Invalid; }
   void setInvalid(bool b = true) const { Invalid = b; }
 

clang/include/clang/Sema/ScopeInfo.h

@@ -144,6 +144,8 @@ class FunctionScopeInfo {
   /// unavailable.
   bool HasPotentialAvailabilityViolations : 1;
 
+  bool HasPotentialFeatureAvailabilityViolations : 1;
+
   /// A flag that is set when parsing a method that must call super's
   /// implementation, such as \c -dealloc, \c -finalize, or any method marked
   /// with \c __attribute__((objc_requires_super)).
@@ -394,7 +396,8 @@ class FunctionScopeInfo {
         HasBranchIntoScope(false), HasIndirectGoto(false), HasMustTail(false),
         HasDroppedStmt(false), HasOMPDeclareReductionCombiner(false),
         HasFallthroughStmt(false), UsesFPIntrin(false),
-        HasPotentialAvailabilityViolations(false), ObjCShouldCallSuper(false),
+        HasPotentialAvailabilityViolations(false),
+        HasPotentialFeatureAvailabilityViolations(false), ObjCShouldCallSuper(false),
         ObjCIsDesignatedInit(false), ObjCWarnForNoDesignatedInitChain(false),
         ObjCIsSecondaryInit(false), ObjCWarnForNoInitDelegation(false),
         NeedsCoroutineSuspends(true), FoundImmediateEscalatingExpression(false),