Merge pull request #5399 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

include/swift/AST/MacroDeclaration.h

@@ -97,8 +97,14 @@ enum class MacroIntroducedDeclNameKind {
   Prefixed,
   Suffixed,
   Arbitrary,
+
+  // NOTE: When adding a new name kind, also add it to
+  // `getAllMacroIntroducedDeclNameKinds`.
 };
 
+/// Returns an enumeratable list of all macro introduced decl name kinds.
+std::vector<MacroIntroducedDeclNameKind> getAllMacroIntroducedDeclNameKinds();
+
 /// Whether a macro-introduced name of this kind requires an argument.
 bool macroIntroducedNameRequiresArgument(MacroIntroducedDeclNameKind kind);
 

include/swift/IDE/CodeCompletionResult.h

@@ -549,6 +549,14 @@ class ContextFreeCodeCompletionResult {
     return NotRecommended;
   }
 
+  ContextualNotRecommendedReason calculateContextualNotRecommendedReason(
+      ContextualNotRecommendedReason explicitReason,
+      bool canCurrDeclContextHandleAsync) const;
+
+  CodeCompletionResultTypeRelation calculateContextualTypeRelation(
+      const DeclContext *dc, const ExpectedTypeContext *typeContext,
+      const USRBasedTypeContext *usrTypeContext) const;
+
   CodeCompletionDiagnosticSeverity getDiagnosticSeverity() const {
     return DiagnosticSeverity;
   }
@@ -611,6 +619,7 @@ class CodeCompletionResult {
   CodeCompletionResultTypeRelation TypeDistance : 3;
   static_assert(int(CodeCompletionResultTypeRelation::MAX_VALUE) < 1 << 3, "");
 
+public:
   /// Memberwise initializer
   /// The \c ContextFree result must outlive this result. Typically, this is
   /// done by allocating the two in the same sink or adopting the context free
@@ -624,25 +633,6 @@ class CodeCompletionResult {
         Flair(Flair.toRaw()), NotRecommended(NotRecommended),
         NumBytesToErase(NumBytesToErase), TypeDistance(TypeDistance) {}
 
-public:
-  /// Enrich a \c ContextFreeCodeCompletionResult with the following contextual
-  /// information.
-  /// This computes the type relation between the completion item and its
-  /// expected type context.
-  /// See \c CodeCompletionResultType::calculateTypeRelation for documentation
-  /// on \p USRTypeContext.
-  /// The \c ContextFree result must outlive this result. Typically, this is
-  /// done by allocating the two in the same sink or adopting the context free
-  /// sink in the sink that allocates this result.
-  CodeCompletionResult(const ContextFreeCodeCompletionResult &ContextFree,
-                       SemanticContextKind SemanticContext,
-                       CodeCompletionFlair Flair, uint8_t NumBytesToErase,
-                       const ExpectedTypeContext *TypeContext,
-                       const DeclContext *DC,
-                       const USRBasedTypeContext *USRTypeContext,
-                       bool CanCurrDeclContextHandleAsync,
-                       ContextualNotRecommendedReason NotRecommended);
-
   const ContextFreeCodeCompletionResult &getContextFreeResult() const {
     return ContextFree;
   }

include/swift/IDE/CompletionLookup.h

@@ -449,8 +449,8 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
       CodeCompletionKeywordKind KeyKind = CodeCompletionKeywordKind::None,
       CodeCompletionFlair flair = {});
 
-  void addDeclAttrParamKeyword(StringRef Name, StringRef Annotation,
-                               bool NeedSpecify);
+  void addDeclAttrParamKeyword(StringRef Name, ArrayRef<StringRef> Parameters,
+                               StringRef Annotation, bool NeedSpecify);
 
   void addDeclAttrKeyword(StringRef Name, StringRef Annotation);
 
@@ -586,7 +586,7 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
   void getAttributeDeclCompletions(bool IsInSil, Optional<DeclKind> DK);
 
   void getAttributeDeclParamCompletions(CustomSyntaxAttributeKind AttrKind,
-                                        int ParamIndex);
+                                        int ParamIndex, bool HasLabel);
 
   void getTypeAttributeKeywordCompletions();
 

include/swift/Parse/IDEInspectionCallbacks.h

@@ -194,7 +194,10 @@ class CodeCompletionCallbacks {
 
   /// Complete the parameters in attribute, for instance, version specifier for
   /// @available.
-  virtual void completeDeclAttrParam(CustomSyntaxAttributeKind DK, int Index){};
+  /// If `HasLabel` is `true`, then the argument already has a label specified,
+  /// e.g. we're completing after `names: ` in a macro declaration.
+  virtual void completeDeclAttrParam(CustomSyntaxAttributeKind DK, int Index,
+                                     bool HasLabel){};
 
   /// Complete 'async' and 'throws' at effects specifier position.
   virtual void completeEffectsSpecifier(bool hasAsync, bool hasThrows) {};

lib/AST/Decl.cpp

@@ -10149,6 +10149,17 @@ StringRef swift::getMacroRoleString(MacroRole role) {
   }
 }
 
+std::vector<MacroIntroducedDeclNameKind>
+swift::getAllMacroIntroducedDeclNameKinds() {
+  return {
+      MacroIntroducedDeclNameKind::Named,
+      MacroIntroducedDeclNameKind::Overloaded,
+      MacroIntroducedDeclNameKind::Prefixed,
+      MacroIntroducedDeclNameKind::Suffixed,
+      MacroIntroducedDeclNameKind::Arbitrary,
+  };
+}
+
 bool swift::macroIntroducedNameRequiresArgument(
   MacroIntroducedDeclNameKind kind
 ) {

lib/ClangImporter/ClangImporter.cpp

@@ -6437,9 +6437,7 @@ static bool hasIteratorAPIAttr(const clang::Decl *decl) {
 static bool hasPointerInSubobjects(const clang::CXXRecordDecl *decl) {
   // Probably a class template that has not yet been specialized:
   if (!decl->getDefinition())
-    // If the definition is unknown, there is no way to determine if the type
-    // stores pointers. Stay on the safe side and assume that it does.
-    return true;
+    return false;
 
   auto checkType = [](clang::QualType t) {
     if (t->isPointerType())
@@ -6734,10 +6732,9 @@ bool IsSafeUseOfCxxDecl::evaluate(Evaluator &evaluator,
           return false;
         }
 
+        // Mark this as safe to help our diganostics down the road.
         if (!cxxRecordReturnType->getDefinition()) {
-          // This is a templated type that has not been instantiated yet. We do
-          // not know if it is safe. Assume that it isn't.
-          return false;
+          return true;
         }
 
         if (!cxxRecordReturnType->hasUserDeclaredCopyConstructor() &&

lib/IDE/CodeCompletion.cpp

@@ -127,6 +127,7 @@ class CodeCompletionCallbacksImpl : public CodeCompletionCallbacks,
   CodeCompletionCallbacks::PrecedenceGroupCompletionKind SyntxKind;
 
   int AttrParamIndex;
+  bool AttrParamHasLabel;
   bool IsInSil = false;
   bool HasSpace = false;
   bool ShouldCompleteCallPatternAfterParen = true;
@@ -270,7 +271,8 @@ class CodeCompletionCallbacksImpl : public CodeCompletionCallbacks,
   void completeCaseStmtKeyword() override;
   void completeCaseStmtBeginning(CodeCompletionExpr *E) override;
   void completeDeclAttrBeginning(bool Sil, bool isIndependent) override;
-  void completeDeclAttrParam(CustomSyntaxAttributeKind DK, int Index) override;
+  void completeDeclAttrParam(CustomSyntaxAttributeKind DK, int Index,
+                             bool HasLabel) override;
   void completeEffectsSpecifier(bool hasAsync, bool hasThrows) override;
   void completeInPrecedenceGroup(
       CodeCompletionCallbacks::PrecedenceGroupCompletionKind SK) override;
@@ -457,10 +459,11 @@ void CodeCompletionCallbacksImpl::completeTypeSimpleBeginning() {
 }
 
 void CodeCompletionCallbacksImpl::completeDeclAttrParam(
-    CustomSyntaxAttributeKind DK, int Index) {
+    CustomSyntaxAttributeKind DK, int Index, bool HasLabel) {
   Kind = CompletionKind::AttributeDeclParen;
   AttrKind = DK;
   AttrParamIndex = Index;
+  AttrParamHasLabel = HasLabel;
   CurDeclContext = P.CurDeclContext;
 }
 
@@ -1844,7 +1847,8 @@ void CodeCompletionCallbacksImpl::doneParsing(SourceFile *SrcFile) {
     break;
   }
   case CompletionKind::AttributeDeclParen: {
-    Lookup.getAttributeDeclParamCompletions(AttrKind, AttrParamIndex);
+    Lookup.getAttributeDeclParamCompletions(AttrKind, AttrParamIndex,
+                                            AttrParamHasLabel);
     break;
   }
   case CompletionKind::PoundAvailablePlatform: {

lib/IDE/CodeCompletionConsumer.cpp

@@ -80,11 +80,19 @@ static MutableArrayRef<CodeCompletionResult *> copyCodeCompletionResults(
     if (!shouldIncludeResult(contextFreeResult)) {
       continue;
     }
+
+    CodeCompletionResultTypeRelation typeRelation =
+        contextFreeResult->calculateContextualTypeRelation(DC, TypeContext,
+                                                           &USRTypeContext);
+    ContextualNotRecommendedReason notRecommendedReason =
+        contextFreeResult->calculateContextualNotRecommendedReason(
+            ContextualNotRecommendedReason::None,
+            CanCurrDeclContextHandleAsync);
+
     auto contextualResult = new (*targetSink.Allocator) CodeCompletionResult(
         *contextFreeResult, SemanticContextKind::OtherModule,
         CodeCompletionFlair(),
-        /*numBytesToErase=*/0, TypeContext, DC, &USRTypeContext,
-        CanCurrDeclContextHandleAsync, ContextualNotRecommendedReason::None);
+        /*numBytesToErase=*/0, typeRelation, notRecommendedReason);
     targetSink.Results.push_back(contextualResult);
   }
 

lib/IDE/CodeCompletionResult.cpp

@@ -392,39 +392,41 @@ bool ContextFreeCodeCompletionResult::getDeclIsSystem(const Decl *D) {
   return D->getModuleContext()->isNonUserModule();
 }
 
-// MARK: - CodeCompletionResult
-
-static ContextualNotRecommendedReason
-getNotRecommenedReason(const ContextFreeCodeCompletionResult &ContextFree,
-                       bool CanCurrDeclContextHandleAsync,
-                       ContextualNotRecommendedReason ExplicitReason) {
-  if (ExplicitReason != ContextualNotRecommendedReason::None) {
-    return ExplicitReason;
-  }
-  if (ContextFree.isAsync() && !CanCurrDeclContextHandleAsync) {
+ContextualNotRecommendedReason
+ContextFreeCodeCompletionResult::calculateContextualNotRecommendedReason(
+    ContextualNotRecommendedReason explicitReason,
+    bool canCurrDeclContextHandleAsync) const {
+  if (explicitReason != ContextualNotRecommendedReason::None) {
+    return explicitReason;
+  }
+  if (IsAsync && !canCurrDeclContextHandleAsync) {
     return ContextualNotRecommendedReason::InvalidAsyncContext;
   }
-  if (ContextFree.hasAsyncAlternative() && CanCurrDeclContextHandleAsync) {
+  if (HasAsyncAlternative && canCurrDeclContextHandleAsync) {
     return ContextualNotRecommendedReason::
         NonAsyncAlternativeUsedInAsyncContext;
   }
   return ContextualNotRecommendedReason::None;
 }
 
-CodeCompletionResult::CodeCompletionResult(
-    const ContextFreeCodeCompletionResult &ContextFree,
-    SemanticContextKind SemanticContext, CodeCompletionFlair Flair,
-    uint8_t NumBytesToErase, const ExpectedTypeContext *TypeContext,
-    const DeclContext *DC, const USRBasedTypeContext *USRTypeContext,
-    bool CanCurrDeclContextHandleAsync,
-    ContextualNotRecommendedReason NotRecommended)
-    : ContextFree(ContextFree), SemanticContext(SemanticContext),
-      Flair(Flair.toRaw()),
-      NotRecommended(getNotRecommenedReason(
-          ContextFree, CanCurrDeclContextHandleAsync, NotRecommended)),
-      NumBytesToErase(NumBytesToErase),
-      TypeDistance(ContextFree.getResultType().calculateTypeRelation(
-          TypeContext, DC, USRTypeContext)) {}
+CodeCompletionResultTypeRelation
+ContextFreeCodeCompletionResult::calculateContextualTypeRelation(
+    const DeclContext *dc, const ExpectedTypeContext *typeContext,
+    const USRBasedTypeContext *usrTypeContext) const {
+  CodeCompletionResultTypeRelation typeRelation =
+      getResultType().calculateTypeRelation(typeContext, dc, usrTypeContext);
+  if (typeRelation >= CodeCompletionResultTypeRelation::Convertible ||
+      !typeContext)
+    return typeRelation;
+
+  CodeCompletionMacroRoles expectedRoles =
+      getCompletionMacroRoles(typeContext->getExpectedCustomAttributeKinds());
+  if (MacroRoles & expectedRoles)
+    return CodeCompletionResultTypeRelation::Convertible;
+  return typeRelation;
+}
+
+// MARK: - CodeCompletionResult
 
 CodeCompletionResult *
 CodeCompletionResult::withFlair(CodeCompletionFlair NewFlair,

lib/IDE/CodeCompletionResultBuilder.cpp

@@ -162,22 +162,27 @@ CodeCompletionResult *CodeCompletionResultBuilder::takeResult() {
     // we don't need to compute any contextual properties.
     return new (Allocator) CodeCompletionResult(
         *ContextFreeResult, SemanticContextKind::None, CodeCompletionFlair(),
-        /*NumBytesToErase=*/0, /*TypeContext=*/nullptr,
-        /*DC=*/nullptr, /*USRTypeContext=*/nullptr,
-        /*CanCurrDeclContextHandleAsync=*/false,
+        /*NumBytesToErase=*/0, CodeCompletionResultTypeRelation::Unrelated,
         ContextualNotRecommendedReason::None);
   } else {
     assert(
         ContextFreeResult != nullptr &&
         "ContextFreeResult should have been constructed by the switch above");
+
     // We know that the ContextFreeResult has an AST-based type because it was
     // just computed and not read from the cache and
     // Sink.shouldProduceContextFreeResults() is false. So we can pass nullptr
     // for USRTypeContext.
+    CodeCompletionResultTypeRelation typeRelation =
+        ContextFreeResult->calculateContextualTypeRelation(
+            DC, TypeContext, /*usrTypeContext=*/nullptr);
+    ContextualNotRecommendedReason notRecommendedReason =
+        ContextFreeResult->calculateContextualNotRecommendedReason(
+            ContextualNotRecReason, CanCurrDeclContextHandleAsync);
+
     return new (Allocator) CodeCompletionResult(
         *ContextFreeResult, SemanticContext, Flair, NumBytesToErase,
-        TypeContext, DC, /*USRTypeContext=*/nullptr,
-        CanCurrDeclContextHandleAsync, ContextualNotRecReason);
+        typeRelation, notRecommendedReason);
   }
 }