Type check ABI decls

Sema now type-checks the alternate ABI-providing decls inside of @abi attributes.

Making this work—particularly, making redeclaration checking work—required making name lookup aware of ABI decls. Name lookup now evaluates both API-providing and ABI-providing declarations. In most cases, it will filter ABI-only decls out unless a specific flag is passed, in which case it will filter API-only decls out instead. Calls that simply retrieve a list of declarations, like `IterableDeclContext::getMembers()` and friends, typically only return API-providing decls; you have to access the ABI-providing ones through those.

As part of that work, I have also added some basic compiler interfaces for working with the API-providing and ABI-providing variants. `ABIRole` encodes whether a declaration provides only API, only ABI, or both, and `ABIRoleInfo` combines that with a pointer to the counterpart providing the other role (for a declaration that provides both, that’ll just be a pointer to `this`).

Decl checking of behavior specific to @abi will come in a future commit.

Note that this probably doesn’t properly exercise some of the new code (ASTScope::lookupEnclosingABIAttributeScope(), for instance); I expect that to happen only once we can rename types using an @abi attribute, since that will create distinguishable behavior differences when resolving TypeReprs in other @abi attributes.

Author: beccadax

include/swift/AST/ASTScope.h

@@ -142,6 +142,7 @@ class ASTScopeImpl : public ASTAllocated<ASTScopeImpl> {
   friend class IterableTypeBodyPortion;
   friend class ScopeCreator;
   friend class ASTSourceFileScope;
+  friend class ABIAttributeScope;
   friend class Lowering::SILGenFunction;
 
 #pragma mark - tree state
@@ -305,6 +306,9 @@ class ASTScopeImpl : public ASTAllocated<ASTScopeImpl> {
       SourceFile *sourceFile, SourceLoc loc,
       llvm::function_ref<bool(ASTScope::PotentialMacro)> consume);
 
+  static ABIAttr *lookupEnclosingABIAttributeScope(
+      SourceFile *sourceFile, SourceLoc loc);
+
   static CatchNode lookupCatchNode(ModuleDecl *module, SourceLoc loc);
 
   /// Scopes that cannot bind variables may set this to true to create more
@@ -946,6 +950,40 @@ class CustomAttributeScope final : public ASTScopeImpl {
   }
 };
 
+/// The scope for ABI attributes and their arguments.
+///
+/// Source locations for the attribute name and its arguments are in the
+/// custom attribute, so lookup is invoked from within the attribute
+/// itself.
+class ABIAttributeScope final : public ASTScopeImpl {
+public:
+  ABIAttr *attr;
+  Decl *decl;
+
+  ABIAttributeScope(ABIAttr *attr, Decl *decl)
+      : ASTScopeImpl(ScopeKind::ABIAttribute), attr(attr), decl(decl) {}
+  virtual ~ABIAttributeScope() {}
+
+protected:
+  ASTScopeImpl *expandSpecifically(ScopeCreator &) override;
+
+public:
+  SourceRange
+  getSourceRangeOfThisASTNode(bool omitAssertions = false) const override;
+  NullablePtr<const void> addressForPrinting() const override { return decl; }
+
+  bool ignoreInDebugInfo() const override { return true; }
+
+private:
+  AnnotatedInsertionPoint
+  expandAScopeThatCreatesANewInsertionPoint(ScopeCreator &);
+
+public:
+  static bool classof(const ASTScopeImpl *scope) {
+    return scope->getKind() == ScopeKind::ABIAttribute;
+  }
+};
+
 /// PatternBindingDecl's (PBDs) are tricky (See the comment for \c
 /// PatternBindingDecl):
 ///

include/swift/AST/ASTScopeNodes.def

@@ -89,6 +89,7 @@ SCOPE_NODE(CaseLabelItem)
 SCOPE_NODE(CaseStmtBody)
 STMT_SCOPE_NODE(BraceStmt)
 EXPR_SCOPE_NODE(Try)
+DECL_ATTRIBUTE_SCOPE_NODE(ABIAttribute)
 
 #undef DECL_ATTRIBUTE_SCOPE_NODE
 #undef EXPR_SCOPE_NODE

include/swift/AST/Attr.h

@@ -3333,7 +3333,7 @@ class ABIAttr : public DeclAttribute {
 
   /// Is this attribute attached to the ABI declaration and pointing back to
   /// the original? Inverse \c ABIAttr s are always implicit and result in an
-  /// \c ABIRole with \c providesAPI() but not \c providesABI() .
+  /// \c ABIRoleInfo with \c providesAPI() but not \c providesABI() .
   bool isInverse() const { return Bits.ABIAttr.isInverse; }
 
   void connectToInverse(Decl *owner) const;

include/swift/AST/Decl.h

@@ -94,6 +94,7 @@ namespace swift {
   class MacroDefinition;
   class ModuleDecl;
   class NamedPattern;
+  enum NLOptions : unsigned;
   class EnumCaseDecl;
   class EnumElementDecl;
   class ParameterList;
@@ -4281,6 +4282,9 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
     IncludeAttrImplements = 1 << 0,
     /// Whether to exclude members of macro expansions.
     ExcludeMacroExpansions = 1 << 1,
+    /// If @abi attributes are present, return the decls representing the ABI,
+    /// not the API.
+    ABIProviding = 1 << 2,
   };
 
   /// Find all of the declarations with the given name within this nominal type
@@ -9669,6 +9673,126 @@ const ParamDecl *getParameterAt(const ValueDecl *source, unsigned index);
 /// nullptr if the source does not have a parameter list.
 const ParamDecl *getParameterAt(const DeclContext *source, unsigned index);
 
+class ABIRole {
+public:
+  enum Value : uint8_t {
+    Neither = 0,
+    ProvidesABI = 1 << 0,
+    ProvidesAPI = 1 << 1,
+    Either = ProvidesABI | ProvidesAPI,
+  };
+
+  Value value;
+
+  ABIRole(Value value)
+    : value(value)
+  { }
+
+  ABIRole()
+    : ABIRole(Neither)
+  { }
+
+  explicit ABIRole(NLOptions opts);
+
+  template<typename FlagType>
+  explicit ABIRole(OptionSet<FlagType> flags)
+    : value(flags.contains(FlagType::ABIProviding) ? ProvidesABI : ProvidesAPI)
+  { }
+
+  inline ABIRole operator|(ABIRole rhs) const {
+    return ABIRole(ABIRole::Value(value | rhs.value));
+  }
+  inline ABIRole &operator|=(ABIRole rhs) {
+    value = ABIRole::Value(value | rhs.value);
+    return *this;
+  }
+  inline ABIRole operator&(ABIRole rhs) const {
+    return ABIRole(ABIRole::Value(value & rhs.value));
+  }
+  inline ABIRole &operator&=(ABIRole rhs) {
+    value = ABIRole::Value(value & rhs.value);
+    return *this;
+  }
+  inline ABIRole operator~() const {
+    return ABIRole(ABIRole::Value(~value));
+  }
+
+  operator bool() const {
+    return value != Neither;
+  }
+};
+
+namespace abi_role_detail {
+
+using Storage = llvm::PointerIntPair<Decl *, 2, ABIRole::Value>;
+Storage computeStorage(Decl *decl);
+
+}
+
+/// Specifies the \c ABIAttr -related behavior of this declaration
+/// and provides access to its counterpart.
+///
+/// A given declaration may provide the API, the ABI, or both. If it provides
+/// API, the counterpart is the matching ABI-providing decl; if it provides
+/// ABI, the countepart is the matching API-providing decl. A declaration
+/// which provides both API and ABI is its own counterpart.
+///
+/// If the counterpart is \c nullptr , this indicates a fundamental mismatch
+/// between decl and counterpart. Sometimes this mismatch is a difference in
+/// decl kind; in these cases, \c getCounterpartUnchecked() will return the
+/// incorrect counterpart.
+template<typename SpecificDecl>
+class ABIRoleInfo {
+  friend abi_role_detail::Storage abi_role_detail::computeStorage(Decl *);
+
+  abi_role_detail::Storage counterpartAndFlags;
+
+  ABIRoleInfo(abi_role_detail::Storage storage)
+    : counterpartAndFlags(storage)
+  { }
+
+public:
+  explicit ABIRoleInfo(const SpecificDecl *decl)
+    : ABIRoleInfo(abi_role_detail::computeStorage(const_cast<SpecificDecl *>(decl)))
+  { }
+
+  Decl *getCounterpartUnchecked() const {
+    return counterpartAndFlags.getPointer();
+  }
+
+  SpecificDecl *getCounterpart() const {
+    return dyn_cast_or_null<SpecificDecl>(getCounterpartUnchecked());
+  }
+
+  ABIRole getRole() const {
+    return ABIRole(ABIRole::Value(counterpartAndFlags.getInt()));
+  }
+
+  bool matches(ABIRole desiredRole) const {
+    return getRole() & desiredRole;
+  }
+
+  template<typename Options>
+  bool matchesOptions(Options opts) const {
+    return matches(ABIRole(opts));
+  }
+
+  bool providesABI() const {
+    return matches(ABIRole::ProvidesABI);
+  }
+
+  bool providesAPI() const {
+    return matches(ABIRole::ProvidesAPI);
+  }
+
+  bool hasABIAttr() const {
+    return !providesABI();
+  }
+};
+
+template<typename SpecificDecl>
+ABIRoleInfo(const SpecificDecl *decl) -> ABIRoleInfo<SpecificDecl>;
+
 StringRef getAccessorNameForDiagnostic(AccessorDecl *accessor, bool article);
 StringRef getAccessorNameForDiagnostic(AccessorKind accessorKind, bool article);
 

include/swift/AST/LookupKinds.h

@@ -64,6 +64,10 @@ enum NLOptions : unsigned {
   /// from a module that has not been imported.
   NL_IgnoreMissingImports = 1 << 9,
 
+  /// If @abi attributes are present, return the decls representing the ABI,
+  /// not the API.
+  NL_ABIProviding = 1 << 10,
+
   /// The default set of options used for qualified name lookup.
   ///
   /// FIXME: Eventually, add NL_ProtocolMembers to this, once all of the
@@ -97,6 +101,9 @@ void simple_display(llvm::raw_ostream &out, NLOptions options);
 enum class ModuleLookupFlags : unsigned {
   /// Exclude names introduced by macro expansions in the top-level module.
   ExcludeMacroExpansions = 1 << 0,
+  /// If @abi attributes are present, return the decls representing the ABI,
+  /// not the API.
+  ABIProviding = 1 << 1,
 };
 
 } // end namespace swift

include/swift/AST/NameLookup.h

@@ -253,6 +253,9 @@ enum class UnqualifiedLookupFlags {
   /// This lookup should include members that would otherwise be filtered out
   /// because they come from a module that has not been imported.
   IgnoreMissingImports = 1 << 10,
+  /// If @abi attributes are present, return the decls representing the ABI,
+  /// not the API.
+  ABIProviding = 1 << 11,
 
   // Reminder: If you add a flag, make sure you update simple_display() below
 };
@@ -555,6 +558,9 @@ template <typename Result>
 void filterForDiscriminator(SmallVectorImpl<Result> &results,
                             DebuggerClient *debugClient);
 
+/// \returns Whether the given source location is inside an \@abi attribute.
+bool isInABIAttr(SourceFile *sourceFile, SourceLoc loc);
+
 /// \returns The set of macro declarations with the given name that
 /// fulfill any of the given macro roles.
 SmallVector<MacroDecl *, 1> lookupMacros(DeclContext *dc,
@@ -749,8 +755,16 @@ class ASTScope : public ASTAllocated<ASTScope> {
   /// local declarations inside the innermost syntactic scope only.
   static void lookupLocalDecls(SourceFile *, DeclName, SourceLoc,
                                bool stopAfterInnermostBraceStmt,
+                               ABIRole roleFilter,
                                SmallVectorImpl<ValueDecl *> &);
 
+  static void lookupLocalDecls(SourceFile *sf, DeclName name, SourceLoc loc,
+                               bool stopAfterInnermostBraceStmt,
+                               SmallVectorImpl<ValueDecl *> &results) {
+    lookupLocalDecls(sf, name, loc, stopAfterInnermostBraceStmt,
+                     ABIRole::ProvidesAPI, results);
+  }
+
   /// Returns the result if there is exactly one, nullptr otherwise.
   static ValueDecl *lookupSingleLocalDecl(SourceFile *, DeclName, SourceLoc);
 
@@ -795,6 +809,18 @@ class ASTScope : public ASTAllocated<ASTScope> {
       SourceFile *sourceFile, SourceLoc loc,
       llvm::function_ref<bool(PotentialMacro macro)> consume);
 
+  /// Look up the scope tree for the nearest enclosing ABI attribute at
+  /// the given source location.
+  ///
+  /// \param sourceFile The source file containing the given location.
+  /// \param loc        The source location to start lookup from.
+  /// \param consume    A function that is called when an ABI attribute
+  ///                   scope is found. If \c consume returns \c true, lookup
+  ///                   will stop. If \c consume returns \c false, lookup will
+  ///                   continue up the scope tree.
+  static ABIAttr *lookupEnclosingABIAttributeScope(
+      SourceFile *sourceFile, SourceLoc loc);
+
   /// Look up the scope tree for the nearest point at which an error thrown from
   /// this location can be caught or rethrown.
   ///

lib/AST/ASTDumper.cpp

@@ -907,6 +907,7 @@ namespace {
                            TerminalColor Color = DeclColor) {
       printFieldQuotedRaw([&](raw_ostream &OS) { declRef.dump(OS); }, label,
                           Color);
+      printFlag(!ABIRoleInfo(declRef.getDecl()).providesAPI(), "abi_only_decl");
     }
 
     void printThrowDest(ThrownErrorDestination throws, bool wantNothrow) {
@@ -1102,6 +1103,8 @@ namespace {
           printFieldQuoted(implAttr->CategoryName.str(), label);
       }
 
+      printFlag(!ABIRoleInfo(D).providesAPI(), "abi_only");
+
       printSourceRange(D->getSourceRange(), &D->getASTContext());
       printFlag(D->TrailingSemiLoc.isValid(), "trailing_semi",
                 DeclModifierColor);

lib/AST/ASTScope.cpp

@@ -67,6 +67,11 @@ void ASTScope::lookupEnclosingMacroScope(
   return ASTScopeImpl::lookupEnclosingMacroScope(sourceFile, loc, body);
 }
 
+ABIAttr *ASTScope::lookupEnclosingABIAttributeScope(
+    SourceFile *sourceFile, SourceLoc loc) {
+  return ASTScopeImpl::lookupEnclosingABIAttributeScope(sourceFile, loc);
+}
+
 CatchNode ASTScope::lookupCatchNode(ModuleDecl *module, SourceLoc loc) {
   return ASTScopeImpl::lookupCatchNode(module, loc);
 }