AST: Parse #_hasSymbol

Introduce the compiler directive `#_hasSymbol` which will be used to detect whether weakly linked symbols are present at runtime. It is intended for use in combination with `@_weakLinked import` or `-weak-link-at-target`.

```
if #_hasSymbol(foo(_:)) {
  foo(42)
}
```

Parsing only; SILGen is coming in a later commit.

Resolves rdar://99342017

Author: tshortli

include/swift/AST/DiagnosticsParse.def

@@ -1280,7 +1280,7 @@ ERROR(string_literal_no_atsign,none,
 ERROR(invalid_float_literal_missing_leading_zero,none,
       "'.%0' is not a valid floating point literal; it must be written '0.%0'",
       (StringRef))
-ERROR(availability_query_outside_if_stmt_guard, none,
+ERROR(special_condition_outside_if_stmt_guard, none,
       "%0 may only be used as condition of an 'if', 'guard'"
       " or 'while' statement", (StringRef))
 
@@ -1935,6 +1935,19 @@ ERROR(availability_cannot_be_mixed,none,
 ERROR(false_available_is_called_unavailable,none,
       "#available cannot be used as an expression, did you mean to use '#unavailable'?", ())
 
+//------------------------------------------------------------------------------
+// MARK: #_hasSymbol query parsing diagnostics
+//------------------------------------------------------------------------------
+
+ERROR(has_symbol_expected_lparen,PointsToFirstBadToken,
+      "expected '(' in #_hasSymbol directive", ())
+
+ERROR(has_symbol_expected_expr,PointsToFirstBadToken,
+      "expected expression in #_hasSymbol", ())
+
+ERROR(has_symbol_expected_rparen,PointsToFirstBadToken,
+      "expected ')' in #_hasSymbol condition", ())
+
 ERROR(attr_requires_concurrency, none,
       "'%0' %select{attribute|modifier}1 is only valid when experimental "
       "concurrency is enabled",

include/swift/AST/Stmt.h

@@ -389,6 +389,39 @@ class alignas(8) PoundAvailableInfo final :
   bool isUnavailability() const { return _isUnavailability; }
 };
 
+/// An expression that guards execution based on whether the symbols for the
+/// declaration identified by the given expression are non-null at run-time, e.g.
+///
+///   if #_hasSymbol(foo(_:)) { foo(42) }
+///
+class PoundHasSymbolInfo final : public ASTAllocated<PoundHasSymbolInfo> {
+  Expr *SymbolExpr;
+
+  SourceLoc PoundLoc;
+  SourceLoc LParenLoc;
+  SourceLoc RParenLoc;
+
+  PoundHasSymbolInfo(SourceLoc PoundLoc, SourceLoc LParenLoc, Expr *SymbolExpr,
+                     SourceLoc RParenLoc)
+      : SymbolExpr(SymbolExpr), PoundLoc(PoundLoc), LParenLoc(LParenLoc),
+        RParenLoc(RParenLoc){};
+
+public:
+  static PoundHasSymbolInfo *create(ASTContext &Ctx, SourceLoc PoundLoc,
+                                    SourceLoc LParenLoc, Expr *SymbolExpr,
+                                    SourceLoc RParenLoc);
+
+  Expr *getSymbolExpr() const { return SymbolExpr; }
+  void setSymbolExpr(Expr *E) { SymbolExpr = E; }
+
+  SourceLoc getLParenLoc() const { return LParenLoc; }
+  SourceLoc getRParenLoc() const { return RParenLoc; }
+  SourceLoc getStartLoc() const { return PoundLoc; }
+  SourceLoc getEndLoc() const { return RParenLoc; }
+  SourceRange getSourceRange() const {
+    return SourceRange(getStartLoc(), getEndLoc());
+  }
+};
 
 /// This represents an entry in an "if" or "while" condition.  Pattern bindings
 /// can bind any number of names in the pattern binding decl, and may have an
@@ -413,47 +446,55 @@ class alignas(1 << PatternAlignInBits) StmtConditionElement {
   /// to this as an 'implicit' pattern.
   Pattern *ThePattern = nullptr;
 
-  /// This is either the boolean condition, the initializer for a pattern
-  /// binding, or the #available information.
-  llvm::PointerUnion<PoundAvailableInfo*, Expr *> CondInitOrAvailable;
+  /// This is either the boolean condition, the #available information, or
+  /// the #_hasSymbol information.
+  llvm::PointerUnion<Expr *, PoundAvailableInfo *, PoundHasSymbolInfo *>
+      Condition;
 
 public:
   StmtConditionElement() {}
-  StmtConditionElement(SourceLoc IntroducerLoc, Pattern *ThePattern,
-                       Expr *Init)
-    : IntroducerLoc(IntroducerLoc), ThePattern(ThePattern),
-      CondInitOrAvailable(Init) {}
-  StmtConditionElement(Expr *cond) : CondInitOrAvailable(cond) {}
+  StmtConditionElement(SourceLoc IntroducerLoc, Pattern *ThePattern, Expr *Init)
+      : IntroducerLoc(IntroducerLoc), ThePattern(ThePattern), Condition(Init) {}
+  StmtConditionElement(Expr *cond) : Condition(cond) {}
+
+  StmtConditionElement(PoundAvailableInfo *Info) : Condition(Info) {}
+
+  StmtConditionElement(PoundHasSymbolInfo *Info) : Condition(Info) {}
 
-  StmtConditionElement(PoundAvailableInfo *Info) : CondInitOrAvailable(Info) {}
-  
   SourceLoc getIntroducerLoc() const { return IntroducerLoc; }
   void setIntroducerLoc(SourceLoc loc) { IntroducerLoc = loc; }
 
   /// ConditionKind - This indicates the sort of condition this is.
   enum ConditionKind {
     CK_Boolean,
     CK_PatternBinding,
-    CK_Availability
+    CK_Availability,
+    CK_HasSymbol,
   };
 
   ConditionKind getKind() const {
-    if (ThePattern) return CK_PatternBinding;
-    return CondInitOrAvailable.is<Expr*>() ? CK_Boolean : CK_Availability;
+    if (ThePattern)
+      return CK_PatternBinding;
+    if (Condition.is<Expr *>())
+      return CK_Boolean;
+    if (Condition.is<PoundAvailableInfo *>())
+      return CK_Availability;
+    assert(Condition.is<PoundHasSymbolInfo *>());
+    return CK_HasSymbol;
   }
 
   /// Boolean Condition Accessors.
   Expr *getBooleanOrNull() const {
-    return getKind() == CK_Boolean ? CondInitOrAvailable.get<Expr*>() : nullptr;
+    return getKind() == CK_Boolean ? Condition.get<Expr *>() : nullptr;
   }
 
   Expr *getBoolean() const {
     assert(getKind() == CK_Boolean && "Not a condition");
-    return CondInitOrAvailable.get<Expr*>();
+    return Condition.get<Expr *>();
   }
   void setBoolean(Expr *E) {
     assert(getKind() == CK_Boolean && "Not a condition");
-    CondInitOrAvailable = E;
+    Condition = E;
   }
 
   /// Pattern Binding Accessors.
@@ -473,22 +514,33 @@ class alignas(1 << PatternAlignInBits) StmtConditionElement {
 
   Expr *getInitializer() const {
     assert(getKind() == CK_PatternBinding && "Not a pattern binding condition");
-    return CondInitOrAvailable.get<Expr*>();
+    return Condition.get<Expr *>();
   }
   void setInitializer(Expr *E) {
     assert(getKind() == CK_PatternBinding && "Not a pattern binding condition");
-    CondInitOrAvailable = E;
+    Condition = E;
   }
 
   // Availability Accessors
   PoundAvailableInfo *getAvailability() const {
     assert(getKind() == CK_Availability && "Not an #available condition");
-    return CondInitOrAvailable.get<PoundAvailableInfo*>();
+    return Condition.get<PoundAvailableInfo *>();
   }
 
   void setAvailability(PoundAvailableInfo *Info) {
     assert(getKind() == CK_Availability && "Not an #available condition");
-    CondInitOrAvailable = Info;
+    Condition = Info;
+  }
+
+  // #_hasSymbol Accessors
+  PoundHasSymbolInfo *getHasSymbolInfo() const {
+    assert(getKind() == CK_HasSymbol && "Not a #_hasSymbol condition");
+    return Condition.get<PoundHasSymbolInfo *>();
+  }
+
+  void setHasSymbolInfo(PoundHasSymbolInfo *Info) {
+    assert(getKind() == CK_HasSymbol && "Not a #_hasSymbol condition");
+    Condition = Info;
   }
 
   SourceLoc getStartLoc() const;

include/swift/Parse/Parser.h

@@ -1839,6 +1839,7 @@ class Parser {
   ParserStatus parseStmtCondition(StmtCondition &Result, Diag<> ID,
                                   StmtKind ParentKind);
   ParserResult<PoundAvailableInfo> parseStmtConditionPoundAvailable();
+  ParserResult<PoundHasSymbolInfo> parseStmtConditionPoundHasSymbol();
   ParserResult<Stmt> parseStmtIf(LabeledStmtInfo LabelInfo,
                                  bool IfWasImplicitlyInserted = false);
   ParserResult<Stmt> parseStmtGuard();

lib/AST/ASTDumper.cpp

@@ -123,6 +123,15 @@ static void printGenericParameters(raw_ostream &OS, GenericParamList *Params) {
   Params->print(OS);
 }
 
+static void printSourceRange(raw_ostream &OS, const SourceRange R,
+                             const ASTContext &Ctx) {
+  if (!R.isValid())
+    return;
+
+  PrintWithColorRAII(OS, RangeColor) << " range=";
+  R.print(PrintWithColorRAII(OS, RangeColor).getOS(), Ctx.SourceMgr,
+          /*PrintText=*/false);
+}
 
 static StringRef
 getSILFunctionTypeRepresentationString(SILFunctionType::Representation value) {
@@ -497,12 +506,7 @@ namespace {
       if (D->isHoisted())
         PrintWithColorRAII(OS, DeclModifierColor) << " hoisted";
 
-      auto R = D->getSourceRange();
-      if (R.isValid()) {
-        PrintWithColorRAII(OS, RangeColor) << " range=";
-        R.print(PrintWithColorRAII(OS, RangeColor).getOS(),
-                D->getASTContext().SourceMgr, /*PrintText=*/false);
-      }
+      printSourceRange(OS, D->getSourceRange(), D->getASTContext());
 
       if (D->TrailingSemiLoc.isValid())
         PrintWithColorRAII(OS, DeclModifierColor) << " trailing_semi";
@@ -1013,12 +1017,7 @@ namespace {
         ctx = &params->get(0)->getASTContext();
 
       if (ctx) {
-        auto R = params->getSourceRange();
-        if (R.isValid()) {
-          PrintWithColorRAII(OS, RangeColor) << " range=";
-          R.print(PrintWithColorRAII(OS, RangeColor).getOS(),
-                  ctx->SourceMgr, /*PrintText=*/false);
-        }
+        printSourceRange(OS, params->getSourceRange(), *ctx);
       }
 
       Indent += 2;
@@ -1483,6 +1482,18 @@ class PrintStmt : public StmtVisitor<PrintStmt> {
       PrintWithColorRAII(OS, ParenthesisColor) << ")";
       Indent -= 2;
       break;
+    case StmtConditionElement::CK_HasSymbol:
+      Indent += 2;
+      OS.indent(Indent);
+      PrintWithColorRAII(OS, ParenthesisColor) << '(';
+      OS << "#_hasSymbol";
+      if (Ctx)
+        printSourceRange(OS, C.getSourceRange(), *Ctx);
+      OS << "\n";
+      printRec(C.getHasSymbolInfo()->getSymbolExpr());
+      PrintWithColorRAII(OS, ParenthesisColor) << ")";
+      Indent -= 2;
+      break;
     }
   }
 
@@ -1494,14 +1505,8 @@ class PrintStmt : public StmtVisitor<PrintStmt> {
     if (S->isImplicit())
       OS << " implicit";
 
-    if (Ctx) {
-      auto R = S->getSourceRange();
-      if (R.isValid()) {
-        PrintWithColorRAII(OS, RangeColor) << " range=";
-        R.print(PrintWithColorRAII(OS, RangeColor).getOS(),
-                Ctx->SourceMgr, /*PrintText=*/false);
-      }
-    }
+    if (Ctx)
+      printSourceRange(OS, S->getSourceRange(), *Ctx);
 
     if (S->TrailingSemiLoc.isValid())
       OS << " trailing_semi";
@@ -1555,9 +1560,10 @@ class PrintStmt : public StmtVisitor<PrintStmt> {
 
   void visitIfStmt(IfStmt *S) {
     printCommon(S, "if_stmt") << '\n';
-    for (auto elt : S->getCond())
+    for (auto elt : S->getCond()) {
       printRec(elt);
-    OS << '\n';
+      OS << "\n";
+    }
     printRec(S->getThenStmt());
     if (S->getElseStmt()) {
       OS << '\n';
@@ -1826,12 +1832,7 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
         L.print(PrintWithColorRAII(OS, LocationColor).getOS(), Ctx.SourceMgr);
       }
 
-      auto R = E->getSourceRange();
-      if (R.isValid()) {
-        PrintWithColorRAII(OS, RangeColor) << " range=";
-        R.print(PrintWithColorRAII(OS, RangeColor).getOS(),
-                Ctx.SourceMgr, /*PrintText=*/false);
-      }
+      printSourceRange(OS, E->getSourceRange(), Ctx);
     }
 
     if (E->TrailingSemiLoc.isValid())

lib/AST/ASTScopeCreation.cpp

@@ -1167,6 +1167,7 @@ ASTScopeImpl *LabeledConditionalStmtScope::createNestedConditionalClauseScopes(
   for (auto &sec : stmt->getCond()) {
     switch (sec.getKind()) {
     case StmtConditionElement::CK_Availability:
+    case StmtConditionElement::CK_HasSymbol:
       break;
     case StmtConditionElement::CK_Boolean:
       scopeCreator.addToScopeTree(sec.getBoolean(), insertionPoint);

lib/AST/ASTVerifier.cpp

@@ -1030,7 +1030,9 @@ class Verifier : public ASTWalker {
 
     void checkConditionElement(const StmtConditionElement &elt) {
       switch (elt.getKind()) {
-      case StmtConditionElement::CK_Availability: break;
+      case StmtConditionElement::CK_Availability:
+      case StmtConditionElement::CK_HasSymbol:
+        break;
       case StmtConditionElement::CK_Boolean: {
         auto *E = elt.getBoolean();
         if (shouldVerifyChecked(E))

lib/AST/ASTWalker.cpp

@@ -1340,7 +1340,9 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
   bool doIt(const StmtCondition &C) {
     for (auto &elt : C) {
       switch (elt.getKind()) {
-      case StmtConditionElement::CK_Availability: break;
+      case StmtConditionElement::CK_Availability:
+      case StmtConditionElement::CK_HasSymbol:
+        break;
       case StmtConditionElement::CK_Boolean: {
         auto E = elt.getBoolean();
         // Walk an expression condition normally.

lib/AST/Stmt.cpp

@@ -368,6 +368,8 @@ SourceRange StmtConditionElement::getSourceRange() const {
     return getBoolean()->getSourceRange();
   case StmtConditionElement::CK_Availability:
     return getAvailability()->getSourceRange();
+  case StmtConditionElement::CK_HasSymbol:
+    return getHasSymbolInfo()->getSourceRange();
   case StmtConditionElement::CK_PatternBinding:
     SourceLoc Start;
     if (IntroducerLoc.isValid())
@@ -386,6 +388,15 @@ SourceRange StmtConditionElement::getSourceRange() const {
   llvm_unreachable("Unhandled StmtConditionElement in switch.");
 }
 
+PoundHasSymbolInfo *PoundHasSymbolInfo::create(ASTContext &Ctx,
+                                               SourceLoc PoundLoc,
+                                               SourceLoc LParenLoc,
+                                               Expr *SymbolExpr,
+                                               SourceLoc RParenLoc) {
+  return new (Ctx)
+      PoundHasSymbolInfo(PoundLoc, LParenLoc, SymbolExpr, RParenLoc);
+}
+
 SourceLoc StmtConditionElement::getStartLoc() const {
   switch (getKind()) {
   case StmtConditionElement::CK_Boolean:
@@ -394,6 +405,8 @@ SourceLoc StmtConditionElement::getStartLoc() const {
     return getAvailability()->getStartLoc();
   case StmtConditionElement::CK_PatternBinding:
     return getSourceRange().Start;
+  case StmtConditionElement::CK_HasSymbol:
+    return getHasSymbolInfo()->getStartLoc();
   }
 
   llvm_unreachable("Unhandled StmtConditionElement in switch.");
@@ -407,6 +420,8 @@ SourceLoc StmtConditionElement::getEndLoc() const {
     return getAvailability()->getEndLoc();
   case StmtConditionElement::CK_PatternBinding:
     return getSourceRange().End;
+  case StmtConditionElement::CK_HasSymbol:
+    return getHasSymbolInfo()->getEndLoc();
   }
 
   llvm_unreachable("Unhandled StmtConditionElement in switch.");