Merge pull request #5200 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

include/swift/AST/Attr.h

@@ -2613,55 +2613,6 @@ class DeclAttributes {
   SourceLoc getStartLoc(bool forModifiers = false) const;
 };
 
-/// Semantic attributes that are applied to a declaration.
-///
-/// This attribute list can include attributes that are not written in
-/// source on a declaration, such as attributes that are applied during
-/// macro expansion or inferred from the declaration context.
-class SemanticDeclAttributes {
-  llvm::SmallVector<DeclAttribute *, 4> attrList;
-
-public:
-  SemanticDeclAttributes() {}
-
-  /// Add a constructed DeclAttribute to this list.
-  void add(DeclAttribute *attr) {
-    attrList.push_back(attr);
-  }
-
-  using SemanticAttrList = llvm::SmallVectorImpl<DeclAttribute *>;
-
-  template <typename AttrType, bool AllowInvalid>
-  using AttributeKindRange =
-      OptionalTransformRange<iterator_range<SemanticAttrList::const_iterator>,
-                             ToAttributeKind<AttrType, AllowInvalid>,
-                             SemanticAttrList::const_iterator>;
-
-  template <typename AttrType, bool AllowInvalid = false>
-  AttributeKindRange<AttrType, AllowInvalid> getAttributes() const {
-    return AttributeKindRange<AttrType, AllowInvalid>(
-        make_range(attrList.begin(), attrList.end()),
-                   ToAttributeKind<AttrType, AllowInvalid>());
-  }
-
-  /// Retrieve the first attribute of the given attribute class.
-  template <typename AttrType>
-  const AttrType *getAttribute(bool allowInvalid = false) const {
-    for (auto attr : attrList)
-      if (auto *specificAttr = dyn_cast<AttrType>(attr))
-        if (specificAttr->isValid() || allowInvalid)
-          return specificAttr;
-
-    return nullptr;
-  }
-
-  /// Determine whether there is an attribute with the given attribute class.
-  template <typename AttrType>
-  bool hasAttribute(bool allowInvalid = false) const {
-    return getAttribute<AttrType>(allowInvalid) != nullptr;
-  }
-};
-
 /// TypeAttributes - These are attributes that may be applied to types.
 class TypeAttributes {
   // Get a SourceLoc for every possible attribute that can be parsed in source.

include/swift/AST/Decl.h

@@ -850,11 +850,10 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     return Attrs;
   }
 
-  /// Returns the semantic attributes attached to this declaration.
-  ///
-  /// \c getSemanticAttrs is intended to be a requestified replacement
-  /// for \c getAttrs
-  SemanticDeclAttributes getSemanticAttrs() const;
+  /// Returns the semantic attributes attached to this declaration,
+  /// including attributes that are generated as the result of member
+  /// attribute macro expansion.
+  DeclAttributes getSemanticAttrs() const;
 
   /// Returns the innermost enclosing decl with an availability annotation.
   const Decl *getInnermostDeclWithAvailability() const;

include/swift/AST/DiagnosticsSema.def

@@ -3886,6 +3886,9 @@ ERROR(unresolved_member_no_inference,none,
       (DeclNameRef))
 ERROR(cannot_infer_base_of_unresolved_member,none,
       "cannot infer contextual base in reference to member %0", (DeclNameRef))
+ERROR(cannot_infer_concrete_for_opaque_result,none,
+      "cannot infer concrete type for opaque result %0 from return expression",
+      (Type))
 ERROR(unresolved_nil_literal,none,
       "'nil' requires a contextual type", ())
 ERROR(cannot_force_unwrap_nil_literal,none,
@@ -5334,6 +5337,12 @@ ERROR(differentiable_function_type_invalid_result,none,
       "%select{| and satisfy '%0 == %0.TangentVector'}1, but the enclosing "
       "function type is '@differentiable%select{|(_linear)}1'",
       (StringRef, bool))
+ERROR(differentiable_function_type_void_result,
+      none,
+      "'@differentiable' function returning Void must have at least one "
+      "differentiable inout parameter, i.e. a non-'@noDerivative' parameter "
+      "whose type conforms to 'Differentiable'",
+      ())
 ERROR(differentiable_function_type_no_differentiability_parameters, 
       none,
       "'@differentiable' function type requires at least one differentiability "

include/swift/AST/SourceFile.h

@@ -500,6 +500,17 @@ class SourceFile final : public FileUnit {
   /// the \c SourceFileKind is \c MacroExpansion.
   ASTNode getMacroExpansion() const;
 
+  /// For source files created to hold the source code created by expanding
+  /// an attached macro, this is the custom attribute that describes the macro
+  /// expansion.
+  ///
+  /// The source location of this attribute is the place in the source that
+  /// triggered the creation of the macro expansion whose resulting source
+  /// code is in this source file. This will only produce a non-null value when
+  /// the \c SourceFileKind is \c MacroExpansion , and the macro is an attached
+  /// macro.
+  CustomAttr *getAttachedMacroAttribute() const;
+
   /// When this source file is enclosed within another source file, for example
   /// because it describes a macro expansion, return the source file it was
   /// enclosed in.

include/swift/AST/TypeCheckRequests.h

@@ -742,26 +742,6 @@ class AttachedPropertyWrappersRequest :
   bool isCached() const { return true; }
 };
 
-/// Request the semantic attributes attached to the given declaration.
-class AttachedSemanticAttrsRequest :
-    public SimpleRequest<AttachedSemanticAttrsRequest,
-                         SemanticDeclAttributes(Decl *),
-                         RequestFlags::Cached> {
-public:
-  using SimpleRequest::SimpleRequest;
-
-private:
-  friend SimpleRequest;
-
-  // Evaluation.
-  SemanticDeclAttributes
-  evaluate(Evaluator &evaluator, Decl *decl) const;
-
-public:
-  // Caching
-  bool isCached() const { return true; }
-};
-
 /// Request the raw (possibly unbound generic) type of the property wrapper
 /// that is attached to the given variable.
 class AttachedPropertyWrapperTypeRequest :
@@ -3840,6 +3820,24 @@ class ExpandMacroExpansionDeclRequest
   bool isCached() const { return true; }
 };
 
+/// Expand all member attribute macros attached to the given
+/// declaration.
+class ExpandMemberAttributeMacros
+    : public SimpleRequest<ExpandMemberAttributeMacros,
+                           bool(Decl *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  bool evaluate(Evaluator &evaluator, Decl *decl) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 /// Resolve an external macro given its module and type name.
 class ExternalMacroDefinitionRequest
     : public SimpleRequest<ExternalMacroDefinitionRequest,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -29,9 +29,6 @@ SWIFT_REQUEST(TypeChecker, AttachedPropertyWrapperTypeRequest,
 SWIFT_REQUEST(TypeChecker, AttachedPropertyWrappersRequest,
               llvm::TinyPtrVector<CustomAttr *>(VarDecl *), Cached,
               NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, AttachedSemanticAttrsRequest,
-              SemanticDeclAttributes(Decl *), Cached,
-              NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, CallerSideDefaultArgExprRequest,
               Expr *(DefaultArgumentExpr *), SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, CheckInconsistentImplementationOnlyImportsRequest,
@@ -455,6 +452,9 @@ SWIFT_REQUEST(TypeChecker, ExternalMacroDefinitionRequest,
 SWIFT_REQUEST(TypeChecker, ExpandMacroExpansionDeclRequest,
               ArrayRef<Decl *>(MacroExpansionDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, ExpandMemberAttributeMacros,
+              bool(Decl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, SynthesizeRuntimeMetadataAttrGenerator,
               Expr *(CustomAttr *, ValueDecl *),
               Cached, NoLocationInfo)

include/swift/Frontend/Frontend.h

@@ -559,6 +559,10 @@ class CompilerInstance {
   /// i.e. if it can be found.
   bool canImportSwiftConcurrency() const;
 
+  /// Whether the Swift Concurrency Shims support Clang library can be imported
+  /// i.e. if it can be found.
+  bool canImportSwiftConcurrencyShims() const;
+
   /// Verify that if an implicit import of the `StringProcessing` module if
   /// expected, it can actually be imported. Emit a warning, otherwise.
   void verifyImplicitStringProcessingImport();

include/swift/Strings.h

@@ -24,6 +24,8 @@ constexpr static const StringLiteral STDLIB_NAME = "Swift";
 constexpr static const StringLiteral SWIFT_ONONE_SUPPORT = "SwiftOnoneSupport";
 /// The name of the Concurrency module, which supports that extension.
 constexpr static const StringLiteral SWIFT_CONCURRENCY_NAME = "_Concurrency";
+/// The name of the Concurrency Shims Clang module
+constexpr static const StringLiteral SWIFT_CONCURRENCY_SHIMS_NAME = "_SwiftConcurrencyShims";
 /// The name of the Distributed module, which supports that extension.
 constexpr static const StringLiteral SWIFT_DISTRIBUTED_NAME = "Distributed";
 /// The name of the StringProcessing module, which supports that extension.

lib/AST/ASTContext.cpp

@@ -5464,7 +5464,10 @@ Type ASTContext::getBridgedToObjC(const DeclContext *dc, Type type,
       *bridgedValueType = type;
 
     // Find the Objective-C class type we bridge to.
-    return conformance.getTypeWitnessByName(type, Id_ObjectiveCType);
+    Type witnessTy = conformance.getTypeWitnessByName(type, Id_ObjectiveCType);
+    // If Objective-C import is broken, witness type would be a dependent member
+    // with `<<error type>>` base.
+    return (witnessTy && !witnessTy->hasError()) ? witnessTy : Type();
   }
 
   // Do we conform to Error?

lib/AST/Decl.cpp

@@ -365,11 +365,13 @@ StringRef Decl::getDescriptiveKindName(DescriptiveDeclKind K) {
   llvm_unreachable("bad DescriptiveDeclKind");
 }
 
-SemanticDeclAttributes Decl::getSemanticAttrs() const {
+DeclAttributes Decl::getSemanticAttrs() const {
   auto mutableThis = const_cast<Decl *>(this);
-  return evaluateOrDefault(getASTContext().evaluator,
-                           AttachedSemanticAttrsRequest{mutableThis},
-                           SemanticDeclAttributes());
+  evaluateOrDefault(getASTContext().evaluator,
+                    ExpandMemberAttributeMacros{mutableThis},
+                    false);
+
+  return getAttrs();
 }
 
 const Decl *Decl::getInnermostDeclWithAvailability() const {

lib/AST/Module.cpp

@@ -887,6 +887,15 @@ ASTNode SourceFile::getMacroExpansion() const {
   return ASTNode::getFromOpaqueValue(genInfo.astNode);
 }
 
+CustomAttr *SourceFile::getAttachedMacroAttribute() const {
+  if (Kind != SourceFileKind::MacroExpansion)
+    return nullptr;
+
+  auto genInfo =
+      *getASTContext().SourceMgr.getGeneratedSourceInfo(*getBufferID());
+  return genInfo.attachedMacroCustomAttr;
+}
+
 SourceFile *SourceFile::getEnclosingSourceFile() const {
   auto macroExpansion = getMacroExpansion();
   if (!macroExpansion)

lib/ClangImporter/ClangImporter.cpp

@@ -5064,6 +5064,9 @@ TinyPtrVector<ValueDecl *> ClangRecordMemberLookup::evaluate(
   if (auto cxxRecord =
           dyn_cast<clang::CXXRecordDecl>(recordDecl->getClangDecl())) {
     for (auto base : cxxRecord->bases()) {
+      if (base.getAccessSpecifier() != clang::AccessSpecifier::AS_public)
+        continue;
+
       clang::QualType baseType = base.getType();
       if (auto spectType = dyn_cast<clang::TemplateSpecializationType>(baseType))
         baseType = spectType->desugar();
@@ -5704,12 +5707,16 @@ clang::FunctionDecl *ClangImporter::instantiateCXXFunctionTemplate(
     std::string failedTypesStr;
     llvm::raw_string_ostream failedTypesStrStream(failedTypesStr);
     llvm::interleaveComma(error->failedTypes, failedTypesStrStream);
+
+    std::string funcName;
+    llvm::raw_string_ostream funcNameStream(funcName);
+    func->printQualifiedName(funcNameStream);
+
     // TODO: Use the location of the apply here.
     // TODO: This error message should not reference implementation details.
     // See: https://github.com/apple/swift/pull/33053#discussion_r477003350
-    ctx.Diags.diagnose(SourceLoc(),
-                       diag::unable_to_convert_generic_swift_types.ID,
-                       {func->getName(), StringRef(failedTypesStr)});
+    ctx.Diags.diagnose(SourceLoc(), diag::unable_to_convert_generic_swift_types,
+                       funcName, failedTypesStr);
     return nullptr;
   }
 

lib/ClangImporter/ImportDecl.cpp

@@ -8442,6 +8442,9 @@ void ClangImporter::Implementation::loadAllMembersOfRecordDecl(
   // If this is a C++ record, look through the base classes too.
   if (auto cxxRecord = dyn_cast<clang::CXXRecordDecl>(clangRecord)) {
     for (auto base : cxxRecord->bases()) {
+      if (base.getAccessSpecifier() != clang::AccessSpecifier::AS_public)
+        continue;
+
       clang::QualType baseType = base.getType();
       if (auto spectType = dyn_cast<clang::TemplateSpecializationType>(baseType))
         baseType = spectType->desugar();

lib/Frontend/Frontend.cpp

@@ -875,6 +875,13 @@ bool CompilerInstance::canImportSwiftConcurrency() const {
   return getASTContext().canImportModule(modulePath);
 }
 
+bool CompilerInstance::canImportSwiftConcurrencyShims() const {
+  ImportPath::Module::Builder builder(
+      getASTContext().getIdentifier(SWIFT_CONCURRENCY_SHIMS_NAME));
+  auto modulePath = builder.get();
+  return getASTContext().canImportModule(modulePath);
+}
+
 void CompilerInstance::verifyImplicitStringProcessingImport() {
   if (Invocation.shouldImportSwiftStringProcessing() &&
       !canImportSwiftStringProcessing()) {
@@ -935,6 +942,8 @@ ImplicitImportInfo CompilerInstance::getImplicitImportInfo() const {
     case ImplicitStdlibKind::Stdlib:
       if (canImportSwiftConcurrency())
         pushImport(SWIFT_CONCURRENCY_NAME);
+      if (canImportSwiftConcurrencyShims())
+        pushImport(SWIFT_CONCURRENCY_SHIMS_NAME);
       break;
     }
   }

lib/Sema/CSDiagnostics.cpp

@@ -5963,6 +5963,16 @@ bool MissingGenericArgumentsFailure::hasLoc(GenericTypeParamType *GP) const {
 }
 
 bool MissingGenericArgumentsFailure::diagnoseAsError() {
+  auto locator = getLocator();
+  // Opaque result types that could not be inferred from return expressions.
+  if (auto opaqueElt =
+          locator->findLast<LocatorPathElt::OpenedOpaqueArchetype>()) {
+    auto *opaqueDecl = opaqueElt->getDecl();
+    emitDiagnostic(diag::cannot_infer_concrete_for_opaque_result,
+                   opaqueDecl->getDeclaredInterfaceType());
+    return true;
+  }
+
   llvm::SmallDenseMap<TypeRepr *, SmallVector<GenericTypeParamType *, 4>>
       scopedParameters;
 

lib/Sema/TypeCheckAttr.cpp

@@ -7385,45 +7385,6 @@ ValueDecl *RenamedDeclRequest::evaluate(Evaluator &evaluator,
   return renamedDecl;
 }
 
-SemanticDeclAttributes
-AttachedSemanticAttrsRequest::evaluate(Evaluator &evaluator, Decl *decl) const {
-  // For now, this returns the same thing as 'getAttrs' using
-  // the SemanticDeclAttribtues representation.
-  SemanticDeclAttributes semanticAttrs;
-  for (auto attr : decl->getAttrs()) {
-    semanticAttrs.add(attr);
-  }
-
-  auto *parentDecl = decl->getDeclContext()->getAsDecl();
-  if (!parentDecl)
-    return semanticAttrs;
-
-  auto parentAttrs = parentDecl->getSemanticAttrs();
-  for (auto customAttrConst: parentAttrs.getAttributes<CustomAttr>()) {
-    auto customAttr = const_cast<CustomAttr *>(customAttrConst);
-    auto customAttrDecl = evaluateOrDefault(
-        evaluator,
-        CustomAttrDeclRequest{
-          customAttr,
-          parentDecl->getInnermostDeclContext()
-        },
-        nullptr);
-    if (!customAttrDecl)
-      continue;
-
-    auto macroDecl = customAttrDecl.dyn_cast<MacroDecl *>();
-    if (!macroDecl)
-      continue;
-
-    if (!macroDecl->getMacroRoles().contains(MacroRole::MemberAttribute))
-      continue;
-
-    expandAttributes(customAttr, macroDecl, decl, semanticAttrs);
-  }
-
-  return semanticAttrs;
-}
-
 template <typename ATTR>
 static void forEachCustomAttribute(
     ValueDecl *decl,