[pull] swiftwasm from main

SwiftCompilerSources/Sources/AST/DiagnosticEngine.swift

@@ -53,17 +53,11 @@ public struct DiagnosticFixIt {
 }
 
 public struct DiagnosticEngine {
-  private let bridged: BridgedDiagnosticEngine
+  private let bridged: swift.DiagnosticEngine
 
-  public init(bridged: BridgedDiagnosticEngine) {
+  public init(bridged: swift.DiagnosticEngine) {
     self.bridged = bridged
   }
-  public init?(bridged: BridgedOptionalDiagnosticEngine) {
-    guard let object = bridged.object else {
-      return nil
-    }
-    self.bridged = BridgedDiagnosticEngine(object: object)
-  }
 
   public func diagnose(_ position: SourceLoc?,
                        _ id: DiagID,

SwiftCompilerSources/Sources/Parse/Regex.swift

@@ -46,7 +46,7 @@ private func _RegexLiteralLexingFn(
   _ curPtrPtr: UnsafeMutablePointer<UnsafePointer<CChar>>,
   _ bufferEndPtr: UnsafePointer<CChar>,
   _ mustBeRegex: CBool,
-  _ bridgedDiagnosticEngine: BridgedOptionalDiagnosticEngine
+  _ bridgedDiagnosticEngine: swift.DiagnosticEngine?
 ) -> /*CompletelyErroneous*/ CBool {
   let inputPtr = curPtrPtr.pointee
 
@@ -62,7 +62,8 @@ private func _RegexLiteralLexingFn(
 
   if let error = error {
     // Emit diagnostic if diagnostics are enabled.
-    if let diagEngine = DiagnosticEngine(bridged: bridgedDiagnosticEngine) {
+    if let bridged = bridgedDiagnosticEngine {
+      let diagEngine = DiagnosticEngine(bridged: bridged)
       let startLoc = SourceLoc(
         locationInFile: error.location.assumingMemoryBound(to: UInt8.self))!
       diagEngine.diagnose(startLoc, .regex_literal_parsing_error, error.message)
@@ -93,7 +94,7 @@ public func _RegexLiteralParsingFn(
   _ captureStructureOut: UnsafeMutableRawPointer,
   _ captureStructureSize: CUnsignedInt,
   _ bridgedDiagnosticBaseLoc: swift.SourceLoc,
-  _ bridgedDiagnosticEngine: BridgedDiagnosticEngine
+  _ bridgedDiagnosticEngine: swift.DiagnosticEngine
 ) -> Bool {
   let str = String(cString: inputPtr)
   let captureBuffer = UnsafeMutableRawBufferPointer(

include/swift/AST/ASTBridging.h

@@ -39,22 +39,12 @@ typedef enum ENUM_EXTENSIBILITY_ATTR(open) BridgedDiagID : uint32_t {
 #include "swift/AST/DiagnosticsAll.def"
 } BridgedDiagID;
 
-typedef struct {
-  void * _Nonnull object;
-} BridgedDiagnosticEngine;
-
-typedef struct {
-  void *_Nullable object;
-} BridgedOptionalDiagnosticEngine;
-
 // FIXME: Can we bridge InFlightDiagnostic?
-void DiagnosticEngine_diagnose(BridgedDiagnosticEngine, swift::SourceLoc loc,
+void DiagnosticEngine_diagnose(swift::DiagnosticEngine &, swift::SourceLoc loc,
                                BridgedDiagID diagID, BridgedArrayRef arguments,
                                swift::CharSourceRange highlight,
                                BridgedArrayRef fixIts);
 
-bool DiagnosticEngine_hadAnyError(BridgedDiagnosticEngine);
-
 SWIFT_END_NULLABILITY_ANNOTATIONS
 
 #endif // SWIFT_AST_ASTBRIDGING_H

include/swift/AST/DiagnosticEngine.h

@@ -781,7 +781,7 @@ namespace swift {
 
   /// Class responsible for formatting diagnostics and presenting them
   /// to the user.
-  class DiagnosticEngine {
+  class SWIFT_IMPORT_REFERENCE DiagnosticEngine {
   public:
     /// The source manager used to interpret source locations and
     /// display diagnostics.

include/swift/AST/DiagnosticsSema.def

@@ -4215,6 +4215,9 @@ NOTE(opaque_type_underlying_type_candidate_here,none,
 ERROR(opaque_type_self_referential_underlying_type,none,
       "function opaque return type was inferred as %0, which defines the "
       "opaque type in terms of itself", (Type))
+ERROR(opaque_type_cannot_contain_dynamic_self,none,
+      "function with opaque return type cannot return "
+      "the covariant 'Self' type of a class", ())
 ERROR(opaque_type_var_no_init,none,
       "property declares an opaque return type, but has no initializer "
       "expression from which to infer an underlying type", ())

include/swift/Basic/Compiler.h

@@ -178,4 +178,11 @@
 #define SWIFT_VFORMAT(fmt)
 #endif
 
+// Tells Swift's ClangImporter to import a C++ type as a foreign reference type.
+#if __has_attribute(swift_attr)
+#define SWIFT_IMPORT_REFERENCE __attribute__((swift_attr("import_as_ref")))
+#else
+#define SWIFT_IMPORT_REFERENCE
+#endif
+
 #endif // SWIFT_BASIC_COMPILER_H

include/swift/IRGen/IRABIDetailsProvider.h

@@ -47,6 +47,16 @@ class IRABIDetailsProvider {
     SizeType alignment;
   };
 
+  /// Information about any ABI additional parameters.
+  struct ABIAdditionalParam {
+    enum class ABIParameterRole { Self, Error };
+
+    ABIParameterRole role;
+    TypeDecl *type;
+  };
+
+  SmallVector<ABIAdditionalParam, 1> ABIAdditionalParams;
+
   /// Returns the size and alignment for the given type, or \c None if the type
   /// is not a fixed layout type.
   llvm::Optional<SizeAndAlignment>
@@ -99,6 +109,10 @@ class IRABIDetailsProvider {
   /// their tag indices from the given EnumDecl
   llvm::MapVector<EnumElementDecl *, unsigned> getEnumTagMapping(EnumDecl *ED);
 
+  /// Returns the additional params if they exist after lowering the function.
+  SmallVector<ABIAdditionalParam, 1>
+  getFunctionABIAdditionalParams(AbstractFunctionDecl *fd);
+
 private:
   std::unique_ptr<IRABIDetailsProviderImpl> impl;
 };

include/swift/Parse/RegexParserBridging.h

@@ -27,16 +27,16 @@
 ///              past.
 /// - MustBeRegex: whether an error during lexing should be considered a regex
 ///                literal, or some thing else.
-/// - BridgedOptionalDiagnosticEngine: RegexLiteralLexingFn should diagnose the
-///                                    token using this engine.
+/// - OptionalDiagnosticEngine: RegexLiteralLexingFn should diagnose the
+///                             token using this engine.
 ///
 /// Returns: A bool indicating whether lexing was completely erroneous, and
 ///          cannot be recovered from, or false if there either was no error,
 ///          or there was a recoverable error.
 typedef bool (*RegexLiteralLexingFn)(
     /*CurPtrPtr*/ const char *_Nonnull *_Nonnull,
     /*BufferEnd*/ const char *_Nonnull,
-    /*MustBeRegex*/ bool, BridgedOptionalDiagnosticEngine);
+    /*MustBeRegex*/ bool, swift::DiagnosticEngine *_Nullable);
 void Parser_registerRegexLiteralLexingFn(RegexLiteralLexingFn _Nullable fn);
 
 /// Parse a regex literal string. Takes the following arguments:
@@ -48,16 +48,16 @@ void Parser_registerRegexLiteralLexingFn(RegexLiteralLexingFn _Nullable fn);
 /// - CaptureStructureSize: The size of the capture structure buffer. Must be
 ///                         greater than or equal to `strlen(InputPtr) + 3`.
 /// - DiagnosticBaseLoc: Start location of the regex literal.
-/// - BridgedDiagnosticEngine: RegexLiteralParsingFn should diagnose the
-///                            parsing errors using this engine.
+/// - DiagnosticEngine: RegexLiteralParsingFn should diagnose the
+///                     parsing errors using this engine.
 ///
 /// Returns: A bool value indicating if there was an error while parsing.
 typedef bool (*RegexLiteralParsingFn)(/*InputPtr*/ const char *_Nonnull,
                                       /*VersionOut*/ unsigned *_Nonnull,
                                       /*CaptureStructureOut*/ void *_Nonnull,
                                       /*CaptureStructureSize*/ unsigned,
                                       /*DiagnosticBaseLoc*/ swift::SourceLoc,
-                                      BridgedDiagnosticEngine);
+                                      swift::DiagnosticEngine &);
 void Parser_registerRegexLiteralParsingFn(RegexLiteralParsingFn _Nullable fn);
 
 #endif // REGEX_PARSER_BRIDGING

include/swift/SIL/SILFunction.h

@@ -472,6 +472,9 @@ class SILFunction
   SILFunction *getDynamicallyReplacedFunction() const {
     return ReplacedFunction;
   }
+
+  static SILFunction *getFunction(SILDeclRef ref, SILModule &M);
+
   void setDynamicallyReplacedFunction(SILFunction *f) {
     assert(ReplacedFunction == nullptr && "already set");
     assert(!hasObjCReplacement());

include/swift/SILOptimizer/Analysis/AccessStorageAnalysis.h

@@ -295,10 +295,7 @@ class FunctionAccessStorage {
   /// the callee.
   ///
   /// TODO: Summarize ArraySemanticsCall accesses.
-  bool summarizeCall(FullApplySite fullApply) {
-    assert(accessResult.isEmpty() && "expected uninitialized results.");
-    return false;
-  }
+  bool summarizeCall(FullApplySite fullApply);
 
   /// Merge effects directly from \p RHS.
   bool mergeFrom(const FunctionAccessStorage &RHS) {

lib/AST/ASTBridging.cpp

@@ -17,28 +17,18 @@
 
 using namespace swift;
 
-namespace {
-/// BridgedDiagnosticEngine -> DiagnosticEngine *.
-DiagnosticEngine *getDiagnosticEngine(const BridgedDiagnosticEngine &bridged) {
-  return static_cast<DiagnosticEngine *>(bridged.object);
-}
-
-} // namespace
-
 void DiagnosticEngine_diagnose(
-    BridgedDiagnosticEngine bridgedEngine, SourceLoc loc,
-    BridgedDiagID bridgedDiagID,
+    DiagnosticEngine &engine, SourceLoc loc, BridgedDiagID bridgedDiagID,
     BridgedArrayRef /*DiagnosticArgument*/ bridgedArguments,
     CharSourceRange highlight,
     BridgedArrayRef /*DiagnosticInfo::FixIt*/ bridgedFixIts) {
-  auto *D = getDiagnosticEngine(bridgedEngine);
 
   auto diagID = static_cast<DiagID>(bridgedDiagID);
   SmallVector<DiagnosticArgument, 2> arguments;
   for (auto arg : getArrayRef<DiagnosticArgument>(bridgedArguments)) {
     arguments.push_back(arg);
   }
-  auto inflight = D->diagnose(loc, diagID, arguments);
+  auto inflight = engine.diagnose(loc, diagID, arguments);
 
   // Add highlight.
   if (highlight.isValid()) {
@@ -52,8 +42,3 @@ void DiagnosticEngine_diagnose(
     inflight.fixItReplaceChars(range.getStart(), range.getEnd(), text);
   }
 }
-
-bool DiagnosticEngine_hadAnyError(BridgedDiagnosticEngine bridgedEngine) {
-  auto *D = getDiagnosticEngine(bridgedEngine);
-  return D->hadAnyError();
-}

lib/ClangImporter/ImportDecl.cpp

@@ -2234,6 +2234,9 @@ namespace {
 
               // Make the actual member operator private.
               MD->overwriteAccess(AccessLevel::Private);
+
+              // Make sure the synthesized decl can be found by lookupDirect.
+              result->addMemberToLookupTable(opFuncDecl);
             }
 
             if (cxxMethod->getDeclName().isIdentifier()) {

lib/ClangImporter/SwiftDeclSynthesizer.cpp

@@ -1881,9 +1881,13 @@ synthesizeOperatorMethodBody(AbstractFunctionDecl *afd, void *context) {
 FuncDecl *
 SwiftDeclSynthesizer::makeOperator(FuncDecl *operatorMethod,
                                    clang::CXXMethodDecl *clangOperator) {
+  clang::OverloadedOperatorKind opKind = clangOperator->getOverloadedOperator();
+
+  assert(opKind != clang::OverloadedOperatorKind::OO_None &&
+         "expected a C++ operator");
+
   auto &ctx = ImporterImpl.SwiftContext;
-  auto opName =
-      clang::getOperatorSpelling(clangOperator->getOverloadedOperator());
+  auto opName = clang::getOperatorSpelling(opKind);
   auto paramList = operatorMethod->getParameters();
   auto genericParamList = operatorMethod->getGenericParams();
 
@@ -1935,6 +1939,11 @@ SwiftDeclSynthesizer::makeOperator(FuncDecl *operatorMethod,
   topLevelStaticFuncDecl->setBodySynthesizer(synthesizeOperatorMethodBody,
                                              operatorMethod);
 
+  // If this is a unary prefix operator (e.g. `!`), add a `prefix` attribute.
+  if (clangOperator->param_empty()) {
+    topLevelStaticFuncDecl->getAttrs().add(new (ctx) PrefixAttr(SourceLoc()));
+  }
+
   return topLevelStaticFuncDecl;
 }
 

lib/IRGen/IRABIDetailsProvider.cpp

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/IRGen/IRABIDetailsProvider.h"
+#include "Callee.h"
 #include "FixedTypeInfo.h"
 #include "GenEnum.h"
 #include "GenType.h"
@@ -21,7 +22,9 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/IRGenOptions.h"
 #include "swift/AST/Types.h"
+#include "swift/SIL/SILFunctionBuilder.h"
 #include "swift/SIL/SILModule.h"
+#include "swift/Subsystems.h"
 #include "clang/CodeGen/ModuleBuilder.h"
 #include "clang/CodeGen/SwiftCallingConv.h"
 #include "llvm/IR/DerivedTypes.h"
@@ -125,8 +128,8 @@ class IRABIDetailsProviderImpl {
 
   llvm::MapVector<EnumElementDecl *, unsigned> getEnumTagMapping(EnumDecl *ED) {
     llvm::MapVector<EnumElementDecl *, unsigned> elements;
-    auto &enumImplStrat = getEnumImplStrategy(
-        IGM, ED->getDeclaredType()->getCanonicalType());
+    auto &enumImplStrat =
+        getEnumImplStrategy(IGM, ED->getDeclaredType()->getCanonicalType());
 
     for (auto *element : ED->getAllElements()) {
       auto tagIdx = enumImplStrat.getTagIndex(element);
@@ -136,6 +139,30 @@ class IRABIDetailsProviderImpl {
     return elements;
   }
 
+  llvm::SmallVector<IRABIDetailsProvider::ABIAdditionalParam, 1>
+  getFunctionABIAdditionalParams(AbstractFunctionDecl *afd) {
+    llvm::SmallVector<IRABIDetailsProvider::ABIAdditionalParam, 1> params;
+
+    auto function = SILFunction::getFunction(SILDeclRef(afd), *silMod);
+
+    auto silFuncType = function->getLoweredFunctionType();
+    auto funcPointerKind =
+        FunctionPointerKind(FunctionPointerKind::BasicKind::Function);
+    auto signature = Signature::getUncached(IGM, silFuncType, funcPointerKind);
+
+    for (auto attrSet : signature.getAttributes()) {
+      if (attrSet.hasAttribute(llvm::Attribute::AttrKind::SwiftSelf))
+        params.push_back(
+            {IRABIDetailsProvider::ABIAdditionalParam::ABIParameterRole::Self,
+             typeConverter.Context.getOpaquePointerDecl()});
+      if (attrSet.hasAttribute(llvm::Attribute::AttrKind::SwiftError))
+        params.push_back(
+            {IRABIDetailsProvider::ABIAdditionalParam::ABIParameterRole::Error,
+             typeConverter.Context.getOpaquePointerDecl()});
+    }
+    return params;
+  }
+
 private:
   Lowering::TypeConverter typeConverter;
   // Default silOptions are sufficient, as we don't need to generated SIL.
@@ -158,6 +185,12 @@ IRABIDetailsProvider::getTypeSizeAlignment(const NominalTypeDecl *TD) {
   return impl->getTypeSizeAlignment(TD);
 }
 
+llvm::SmallVector<IRABIDetailsProvider::ABIAdditionalParam, 1>
+IRABIDetailsProvider::getFunctionABIAdditionalParams(
+    AbstractFunctionDecl *afd) {
+  return impl->getFunctionABIAdditionalParams(afd);
+}
+
 bool IRABIDetailsProvider::shouldPassIndirectly(Type t) {
   return impl->shouldPassIndirectly(t);
 }

lib/Parse/Lexer.cpp

@@ -15,7 +15,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/Parse/Lexer.h"
-#include "swift/AST/BridgingUtils.h"
 #include "swift/AST/DiagnosticsParse.h"
 #include "swift/AST/Identifier.h"
 #include "swift/Basic/LangOptions.h"
@@ -2091,7 +2090,7 @@ const char *Lexer::tryScanRegexLiteral(const char *TokStart, bool MustBeRegex,
   //   recovered from.
   auto *Ptr = TokStart;
   CompletelyErroneous = regexLiteralLexingFn(
-      &Ptr, BufferEnd, MustBeRegex, getBridgedOptionalDiagnosticEngine(Diags));
+      &Ptr, BufferEnd, MustBeRegex, Diags);
 
   // If we didn't make any lexing progress, this isn't a regex literal and we
   // should fallback to lexing as something else.