Merge pull request #65523 from ahoppen/ahoppen/5.9/macro-attribute-completions

ahoppen · web-flow · commit f023fd3ffdac · 2023-05-01T14:32:45.000-07:00
[5.9] [CodeCompletion] Support completion for macro roles and the 'names:' argument label
diff --git a/include/swift/AST/DiagnosticsCommon.def b/include/swift/AST/DiagnosticsCommon.def
@@ -220,7 +220,7 @@ ERROR(unknown_attribute,none,
 NOTE(in_macro_expansion,none,
      "in expansion of macro %0 here", (DeclName))
 ERROR(macro_experimental,none,
-      "%0 macros are an experimental feature that is not enabled (%1)",
+      "%0 macros are an experimental feature that is not enabled %select{|(%1)}1",
       (StringRef, StringRef))
 ERROR(ambiguous_macro_reference,none,
       "ambiguous reference to macro %0", (DeclName))
diff --git a/include/swift/AST/MacroDeclaration.h b/include/swift/AST/MacroDeclaration.h
@@ -58,8 +58,13 @@ enum class MacroRole: uint32_t {
   /// A freestanding macro that expands to expressions, statements and
   /// declarations in a code block.
   CodeItem = 0x80,
+
+  // NOTE: When adding a new macro role, also add it to `getAllMacroRoles`.
 };
 
+/// Returns an enumeratable list of all macro roles.
+std::vector<MacroRole> getAllMacroRoles();
+
 /// The contexts in which a particular macro declaration can be used.
 using MacroRoles = OptionSet<MacroRole>;
 
@@ -83,6 +88,9 @@ bool isAttachedMacro(MacroRoles contexts);
 
 MacroRoles getAttachedMacroRoles();
 
+/// Checks if the macro is supported or guarded behind an experimental flag.
+bool isMacroSupported(MacroRole role, ASTContext &ctx);
+
 enum class MacroIntroducedDeclNameKind {
   Named,
   Overloaded,
diff --git a/include/swift/IDE/CompletionLookup.h b/include/swift/IDE/CompletionLookup.h
@@ -585,7 +585,8 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
 
   void getAttributeDeclCompletions(bool IsInSil, Optional<DeclKind> DK);
 
-  void getAttributeDeclParamCompletions(DeclAttrKind AttrKind, int ParamIndex);
+  void getAttributeDeclParamCompletions(CustomSyntaxAttributeKind AttrKind,
+                                        int ParamIndex);
 
   void getTypeAttributeKeywordCompletions();
 
diff --git a/include/swift/Parse/IDEInspectionCallbacks.h b/include/swift/Parse/IDEInspectionCallbacks.h
@@ -29,6 +29,15 @@ enum class ObjCSelectorContext {
   SetterSelector
 };
 
+/// Attributes that have syntax which can't be modelled using a function call.
+/// This can't be \c DeclAttrKind because '@freestandig' and '@attached' have
+/// the same attribute kind but take different macro roles as arguemnts.
+enum class CustomSyntaxAttributeKind {
+  Available,
+  FreestandingMacro,
+  AttachedMacro,
+};
+
 /// Parser's interface to code completion.
 class CodeCompletionCallbacks {
 protected:
@@ -185,7 +194,7 @@ class CodeCompletionCallbacks {
 
   /// Complete the parameters in attribute, for instance, version specifier for
   /// @available.
-  virtual void completeDeclAttrParam(DeclAttrKind DK, int Index) {};
+  virtual void completeDeclAttrParam(CustomSyntaxAttributeKind DK, int Index){};
 
   /// Complete 'async' and 'throws' at effects specifier position.
   virtual void completeEffectsSpecifier(bool hasAsync, bool hasThrows) {};
diff --git a/include/swift/Parse/Parser.h b/include/swift/Parse/Parser.h
@@ -1024,9 +1024,10 @@ class Parser {
                                       PatternBindingInitializer *initContext);
 
   /// Parse the optional modifiers before a declaration.
-  bool parseDeclModifierList(DeclAttributes &Attributes, SourceLoc &StaticLoc,
-                             StaticSpellingKind &StaticSpelling,
-                             bool isFromClangAttribute = false);
+  ParserStatus parseDeclModifierList(DeclAttributes &Attributes,
+                                     SourceLoc &StaticLoc,
+                                     StaticSpellingKind &StaticSpelling,
+                                     bool isFromClangAttribute = false);
 
   /// Parse an availability attribute of the form
   /// @available(*, introduced: 1.0, deprecated: 3.1).
@@ -1138,9 +1139,9 @@ class Parser {
   ParserResult<CustomAttr> parseCustomAttribute(
       SourceLoc atLoc, PatternBindingInitializer *&initContext);
 
-  bool parseNewDeclAttribute(DeclAttributes &Attributes, SourceLoc AtLoc,
-                             DeclAttrKind DK,
-                             bool isFromClangAttribute = false);
+  ParserStatus parseNewDeclAttribute(DeclAttributes &Attributes,
+                                     SourceLoc AtLoc, DeclAttrKind DK,
+                                     bool isFromClangAttribute = false);
 
   /// Parse a version tuple of the form x[.y[.z]]. Returns true if there was
   /// an error parsing.
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -10101,6 +10101,14 @@ BuiltinTupleDecl::BuiltinTupleDecl(Identifier Name, DeclContext *Parent)
     : NominalTypeDecl(DeclKind::BuiltinTuple, Parent, Name, SourceLoc(),
                       ArrayRef<InheritedEntry>(), nullptr) {}
 
+std::vector<MacroRole> swift::getAllMacroRoles() {
+  return {
+      MacroRole::Expression,      MacroRole::Declaration, MacroRole::Accessor,
+      MacroRole::MemberAttribute, MacroRole::Member,      MacroRole::Peer,
+      MacroRole::Conformance,     MacroRole::CodeItem,
+  };
+}
+
 StringRef swift::getMacroRoleString(MacroRole role) {
   switch (role) {
   case MacroRole::Expression:
@@ -10192,6 +10200,21 @@ MacroRoles swift::getAttachedMacroRoles() {
   return attachedMacroRoles;
 }
 
+bool swift::isMacroSupported(MacroRole role, ASTContext &ctx) {
+  switch (role) {
+  case MacroRole::Expression:
+  case MacroRole::Declaration:
+  case MacroRole::Accessor:
+  case MacroRole::MemberAttribute:
+  case MacroRole::Member:
+  case MacroRole::Peer:
+  case MacroRole::Conformance:
+    return true;
+  case MacroRole::CodeItem:
+    return ctx.LangOpts.hasFeature(Feature::CodeItemMacros);
+  }
+}
+
 void MissingDecl::forEachMacroExpandedDecl(MacroExpandedDeclCallback callback) {
   auto macroRef = unexpandedMacro.macroRef;
   auto *baseDecl = unexpandedMacro.baseDecl;
diff --git a/lib/ClangImporter/ImportDecl.cpp b/lib/ClangImporter/ImportDecl.cpp
@@ -7682,9 +7682,11 @@ ClangImporter::Implementation::importSwiftAttrAttributes(Decl *MappedDecl) {
       } else {
         SourceLoc staticLoc;
         StaticSpellingKind staticSpelling;
-        hadError = parser.parseDeclModifierList(
-            MappedDecl->getAttrs(), staticLoc, staticSpelling,
-            /*isFromClangAttribute=*/true);
+        hadError = parser
+                       .parseDeclModifierList(MappedDecl->getAttrs(), staticLoc,
+                                              staticSpelling,
+                                              /*isFromClangAttribute=*/true)
+                       .isError();
       }
 
       if (hadError) {
diff --git a/lib/IDE/CodeCompletion.cpp b/lib/IDE/CodeCompletion.cpp
@@ -113,7 +113,7 @@ class CodeCompletionCallbacksImpl : public CodeCompletionCallbacks,
   SourceLoc DotLoc;
   TypeLoc ParsedTypeLoc;
   DeclContext *CurDeclContext = nullptr;
-  DeclAttrKind AttrKind;
+  CustomSyntaxAttributeKind AttrKind;
 
   /// When the code completion token occurs in a custom attribute, the attribute
   /// it occurs in. Used so we can complete inside the attribute even if it's
@@ -270,7 +270,7 @@ class CodeCompletionCallbacksImpl : public CodeCompletionCallbacks,
   void completeCaseStmtKeyword() override;
   void completeCaseStmtBeginning(CodeCompletionExpr *E) override;
   void completeDeclAttrBeginning(bool Sil, bool isIndependent) override;
-  void completeDeclAttrParam(DeclAttrKind DK, int Index) override;
+  void completeDeclAttrParam(CustomSyntaxAttributeKind DK, int Index) override;
   void completeEffectsSpecifier(bool hasAsync, bool hasThrows) override;
   void completeInPrecedenceGroup(
       CodeCompletionCallbacks::PrecedenceGroupCompletionKind SK) override;
@@ -456,8 +456,8 @@ void CodeCompletionCallbacksImpl::completeTypeSimpleBeginning() {
   CurDeclContext = P.CurDeclContext;
 }
 
-void CodeCompletionCallbacksImpl::completeDeclAttrParam(DeclAttrKind DK,
-                                                        int Index) {
+void CodeCompletionCallbacksImpl::completeDeclAttrParam(
+    CustomSyntaxAttributeKind DK, int Index) {
   Kind = CompletionKind::AttributeDeclParen;
   AttrKind = DK;
   AttrParamIndex = Index;
diff --git a/lib/IDE/CompletionLookup.cpp b/lib/IDE/CompletionLookup.cpp
@@ -3011,9 +3011,10 @@ void CompletionLookup::getAttributeDeclCompletions(bool IsInSil,
 #include "swift/AST/Attr.def"
 }
 
-void CompletionLookup::getAttributeDeclParamCompletions(DeclAttrKind AttrKind,
-                                                        int ParamIndex) {
-  if (AttrKind == DAK_Available) {
+void CompletionLookup::getAttributeDeclParamCompletions(
+    CustomSyntaxAttributeKind AttrKind, int ParamIndex) {
+  switch (AttrKind) {
+  case CustomSyntaxAttributeKind::Available:
     if (ParamIndex == 0) {
       addDeclAttrParamKeyword("*", "Platform", false);
 
@@ -3029,6 +3030,28 @@ void CompletionLookup::getAttributeDeclParamCompletions(DeclAttrKind AttrKind,
       addDeclAttrParamKeyword("introduced", "Specify version number", true);
       addDeclAttrParamKeyword("deprecated", "Specify version number", true);
     }
+    break;
+  case CustomSyntaxAttributeKind::FreestandingMacro:
+  case CustomSyntaxAttributeKind::AttachedMacro:
+    switch (ParamIndex) {
+    case 0:
+      for (auto role : getAllMacroRoles()) {
+        bool isRoleSupported = isMacroSupported(role, Ctx);
+        if (AttrKind == CustomSyntaxAttributeKind::FreestandingMacro) {
+          isRoleSupported &= isFreestandingMacro(role);
+        } else if (AttrKind == CustomSyntaxAttributeKind::AttachedMacro) {
+          isRoleSupported &= isAttachedMacro(role);
+        }
+        if (isRoleSupported) {
+          addDeclAttrParamKeyword(getMacroRoleString(role), "", false);
+        }
+      }
+      break;
+    case 1:
+      addDeclAttrParamKeyword("names", "Specify declared names", true);
+      break;
+    }
+    break;
   }
 }
 
@@ -3103,7 +3126,7 @@ void CompletionLookup::getPrecedenceGroupCompletions(
 void CompletionLookup::getPoundAvailablePlatformCompletions() {
 
   // The platform names should be identical to those in @available.
-  getAttributeDeclParamCompletions(DAK_Available, 0);
+  getAttributeDeclParamCompletions(CustomSyntaxAttributeKind::Available, 0);
 }
 
 void CompletionLookup::getSelfTypeCompletionInDeclContext(
diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
diff --git a/test/IDE/complete_macro_attribute.swift b/test/IDE/complete_macro_attribute.swift
diff --git a/test/Macros/macro_codeitems_disabled.swift b/test/Macros/macro_codeitems_disabled.swift
diff --git a/test/Macros/macros_diagnostics.swift b/test/Macros/macros_diagnostics.swift
