Merge pull request #4338 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

benchmark/single-source/NSStringConversion.swift

@@ -102,7 +102,21 @@ public let benchmarks = [
   BenchmarkInfo(name: "NSStringConversion.MutableCopy.Rebridge.LongUTF8",
                 runFunction: run_NSStringConversion_longNonASCII_rebridgeMutable,
                 tags: [.validation, .api, .String, .bridging],
-                setUpFunction: { mutableTest = "Thë qüick bröwn föx jumps over the lazy dög" } )
+                setUpFunction: { mutableTest = "Thë qüick bröwn föx jumps over the lazy dög" } ),
+  BenchmarkInfo(name: "NSStringConversion.InlineBuffer.UTF8",
+                runFunction: run_NSStringConversion_inlineBuffer,
+                tags: [.validation, .api, .String, .bridging],
+                setUpFunction: {
+                  mutableTest = Array(repeating: "제10회 유니코드 국제 회의가 1997년 3월 10일부터 12일까지 독일의 마인즈에서 열립니다. 지금 등록하십시오. 이 회의에서는 업계 전반의 전문가들이 함께 모여 다음과 같은 분야를 다룹니다. - 인터넷과 유니코드, 국제화와 지역화, 운영 체제와 응용 프로그램에서 유니코드의 구현, 글꼴, 문자 배열, 다국어 컴퓨팅.세계를 향한 대화, 유니코드로 하십시오. 제10회 유니코드 국제 회의가 1997년 3월 10일부터 12일까지 독일의 마인즈에서 열립니다. 지금 등록하십시오. 이 회의에서는 업계 전반의 전문가들이 함께 모여 다음과 같은 분야를 다룹니다. 세계를 향한 대화, 유니코드로 하십시오.", count: 256).joined(separator: "")
+                }
+               ),
+  BenchmarkInfo(name: "NSStringConversion.InlineBuffer.ASCII",
+                runFunction: run_NSStringConversion_inlineBuffer,
+                tags: [.validation, .api, .String, .bridging],
+                setUpFunction: {
+                  mutableTest = Array(repeating: "The 10th Unicode International Conference will be held from March 10 to 12, 1997 in Mainz, Germany. Register now. The conference brings together experts from across the industry, covering areas such as: - Internet and Unicode, internationalization and localization, implementation of Unicode in operating systems and applications, fonts, character arrays, multilingual computing. Dialogue to the world, do Unicode. The 10th Unicode International Conference will be held from March 10 to 12, 1997 in Mainz, Germany. Register now. The conference brings together experts from across the industry, covering areas such as: Dialogue to the world, do it in Unicode.", count: 256).joined(separator: "")
+                }
+               )
 ]
 
 public func run_NSStringConversion(_ n: Int) {
@@ -227,4 +241,24 @@ public func run_NSStringConversion_longNonASCII_rebridgeMutable(_ n: Int) {
   innerMutableRebridge(mutableTest, n, 300)
 }
 
+public func run_NSStringConversion_inlineBuffer(_ n: Int) {
+  withUnsafeTemporaryAllocation(
+    of: CFStringInlineBuffer.self,
+    capacity: 1
+  ) { bufferPtr in
+    let buffer = bufferPtr.baseAddress!
+    for _ in 0 ..< n {
+      var result = UInt64(0)
+      let bridged = mutableTest as NSString as CFString
+      let len = CFStringGetLength(bridged)
+      CFStringInitInlineBuffer(bridged, buffer, CFRangeMake(0, len))
+      for i in 0 ..< CFStringGetLength(bridged) {
+        let char = CFStringGetCharacterFromInlineBuffer(buffer, i)
+        result += UInt64(char)
+      }
+      blackHole(result)
+    }
+  }
+}
+
 #endif

include/swift/AST/ActorIsolation.h

@@ -109,6 +109,19 @@ class ActorIsolation {
 
   bool isIndependent() const { return kind == Independent; }
 
+  bool isActorIsolated() const {
+    switch (getKind()) {
+    case ActorInstance:
+    case GlobalActor:
+    case GlobalActorUnsafe:
+      return true;
+
+    case Unspecified:
+    case Independent:
+      return false;
+    }
+  }
+
   NominalTypeDecl *getActor() const {
     assert(getKind() == ActorInstance);
     return actor;

include/swift/AST/DiagnosticsSema.def

@@ -6112,6 +6112,15 @@ WARNING(result_builder_missing_limited_availability, none,
 ERROR(result_builder_static_buildblock, none,
       "result builder must provide at least one static 'buildBlock' "
       "method", ())
+ERROR(result_builder_static_buildblock_or_buildpartialblock, none,
+      "result builder must provide at least one static 'buildBlock' "
+      "method, or both 'buildPartialBlock(first:)' and "
+      "'buildPartialBlock(accumulated:next:)'", ())
+ERROR(result_builder_missing_available_buildpartialblock, none,
+      "result builder %0 does not implement any 'buildBlock' or a combination "
+      "of 'buildPartialBlock(first:)' and "
+      "'buildPartialBlock(accumulated:next:)' with sufficient availability for "
+      "this call site", (Type))
 NOTE(result_builder_non_static_buildblock, none,
      "did you mean to make instance method 'buildBlock' static?", ())
 NOTE(result_builder_buildblock_enum_case, none,

include/swift/AST/KnownIdentifiers.def

@@ -28,6 +28,7 @@ IDENTIFIER(allKeys)
 IDENTIFIER(alloc)
 IDENTIFIER(allocWithZone)
 IDENTIFIER(allZeros)
+IDENTIFIER(accumulated)
 IDENTIFIER(ActorType)
 IDENTIFIER(Any)
 IDENTIFIER(ArrayLiteralElement)
@@ -41,6 +42,7 @@ IDENTIFIER(buildFinalResult)
 IDENTIFIER(buildIf)
 IDENTIFIER(buildLimitedAvailability)
 IDENTIFIER(buildOptional)
+IDENTIFIER(buildPartialBlock)
 IDENTIFIER(callAsFunction)
 IDENTIFIER(Change)
 IDENTIFIER_WITH_NAME(code_, "_code")

include/swift/Basic/Features.def

@@ -75,5 +75,7 @@ SUPPRESSIBLE_LANGUAGE_FEATURE(SpecializeAttributeWithAvailability, 0, "@_special
 LANGUAGE_FEATURE(BuiltinAssumeAlignment, 0, "Builtin.assumeAlignment", true)
 SUPPRESSIBLE_LANGUAGE_FEATURE(UnsafeInheritExecutor, 0, "@_unsafeInheritExecutor", true)
 SUPPRESSIBLE_LANGUAGE_FEATURE(PrimaryAssociatedTypes, 0, "Primary associated types", true)
+SUPPRESSIBLE_LANGUAGE_FEATURE(UnavailableFromAsync, 0, "@_unavailableFromAsync", true)
+
 #undef SUPPRESSIBLE_LANGUAGE_FEATURE
 #undef LANGUAGE_FEATURE

lib/AST/ASTPrinter.cpp

@@ -3002,6 +3002,19 @@ static void suppressingFeaturePrimaryAssociatedTypes(PrintOptions &options,
   options.PrintPrimaryAssociatedTypes = originalPrintPrimaryAssociatedTypes;
 }
 
+static bool usesFeatureUnavailableFromAsync(Decl *decl) {
+  return decl->getAttrs().hasAttribute<UnavailableFromAsyncAttr>();
+}
+
+static void
+suppressingFeatureUnavailableFromAsync(PrintOptions &options,
+                                       llvm::function_ref<void()> action) {
+  unsigned originalExcludeAttrCount = options.ExcludeAttrList.size();
+  options.ExcludeAttrList.push_back(DAK_UnavailableFromAsync);
+  action();
+  options.ExcludeAttrList.resize(originalExcludeAttrCount);
+}
+
 /// Suppress the printing of a particular feature.
 static void suppressingFeature(PrintOptions &options, Feature feature,
                                llvm::function_ref<void()> action) {

lib/ClangImporter/ImportType.cpp

@@ -546,6 +546,12 @@ namespace {
         return importFunctionPointerLikeType(*type, pointeeType);
       }
 
+      // Currently, we can't generate thunks for references to dependent types
+      // because there's no way to cast without a copy (without writing the SIL
+      // manually).
+      if (pointeeQualType->isDependentType())
+        return Type();
+
       if (Impl.isOverAligned(pointeeQualType)) {
         return importOverAlignedFunctionPointerLikeType(*type, Impl);
       }
@@ -1857,6 +1863,17 @@ ImportedType ClangImporter::Implementation::importFunctionParamsAndReturnType(
           dyn_cast<clang::TemplateTypeParmType>(clangDecl->getReturnType())) {
     importedType = {findGenericTypeInGenericDecls(templateType, genericParams),
                     false};
+  } else if ((isa<clang::PointerType>(clangDecl->getReturnType()) ||
+          isa<clang::ReferenceType>(clangDecl->getReturnType())) &&
+         isa<clang::TemplateTypeParmType>(clangDecl->getReturnType()->getPointeeType())) {
+    auto pointeeType = clangDecl->getReturnType()->getPointeeType();
+    auto templateParamType = cast<clang::TemplateTypeParmType>(pointeeType);
+    PointerTypeKind pointerKind = pointeeType.getQualifiers().hasConst()
+                                      ? PTK_UnsafePointer
+                                      : PTK_UnsafeMutablePointer;
+    auto genericType =
+        findGenericTypeInGenericDecls(templateParamType, genericParams);
+    importedType = {genericType->wrapInPointer(pointerKind), false};
   } else if (!(isa<clang::RecordType>(clangDecl->getReturnType()) ||
                isa<clang::TemplateSpecializationType>(clangDecl->getReturnType())) ||
              // TODO: we currently don't lazily load operator return types, but

lib/FrontendTool/TBD.cpp

@@ -56,6 +56,27 @@ bool swift::writeTBD(ModuleDecl *M, StringRef OutputFilename,
   return false;
 }
 
+/// Determine if a symbol name is ignored when validating the TBD's contents
+/// against the IR's.
+///
+/// \param name The name of the symbol in question.
+/// \param IRModule The module being validated.
+///
+/// \returns Whether or not the presence or absence of the symbol named \a name
+///   should be ignored (instead of potentially producing a diagnostic.)
+static bool isSymbolIgnored(const StringRef& name,
+                            const llvm::Module &IRModule) {
+  if (llvm::Triple(IRModule.getTargetTriple()).isOSWindows()) {
+    // (SR-15938) Error when referencing #dsohandle in a Swift test on Windows
+    // On Windows, ignore the lack of __ImageBase in the TBD file.
+    if (name == "__ImageBase") {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 static bool validateSymbols(DiagnosticEngine &diags,
                             const std::vector<std::string> &symbols,
                             const llvm::Module &IRModule,
@@ -77,6 +98,11 @@ static bool validateSymbols(DiagnosticEngine &diags,
     // with what TBDGen created.
     auto unmangledName = nameValue.getKey();
 
+    if (isSymbolIgnored(unmangledName, IRModule)) {
+      // This symbol should not affect validation. Skip it.
+      continue;
+    }
+
     SmallString<128> name;
     llvm::Mangler::getNameWithPrefix(name, unmangledName,
                                      IRModule.getDataLayout());

lib/IDE/CodeCompletion.cpp

@@ -283,7 +283,7 @@ class CodeCompletionCallbacksImpl : public CodeCompletionCallbacks {
 static void addSelectorModifierKeywords(CodeCompletionResultSink &sink) {
   auto addKeyword = [&](StringRef Name, CodeCompletionKeywordKind Kind) {
     CodeCompletionResultBuilder Builder(sink, CodeCompletionResultKind::Keyword,
-                                        SemanticContextKind::None, {});
+                                        SemanticContextKind::None);
     Builder.setKeywordKind(Kind);
     Builder.addTextChunk(Name);
     Builder.addCallParameterColon();
@@ -646,7 +646,7 @@ static void addKeyword(CodeCompletionResultSink &Sink, StringRef Name,
                        StringRef TypeAnnotation = "",
                        CodeCompletionFlair Flair = {}) {
   CodeCompletionResultBuilder Builder(Sink, CodeCompletionResultKind::Keyword,
-                                      SemanticContextKind::None, {});
+                                      SemanticContextKind::None);
   Builder.setKeywordKind(Kind);
   Builder.addKeyword(Name);
   Builder.addFlair(Flair);
@@ -868,7 +868,7 @@ static void addSuperKeyword(CodeCompletionResultSink &Sink, DeclContext *DC) {
     return;
 
   CodeCompletionResultBuilder Builder(Sink, CodeCompletionResultKind::Keyword,
-                                      SemanticContextKind::CurrentNominal, {});
+                                      SemanticContextKind::CurrentNominal);
   if (auto *AFD = dyn_cast<AbstractFunctionDecl>(DC)) {
     if (AFD->getOverriddenDecl() != nullptr) {
       Builder.addFlair(CodeCompletionFlairBit::CommonKeywordAtCurrentPosition);
@@ -886,7 +886,7 @@ static void addOpaqueTypeKeyword(CodeCompletionResultSink &Sink) {
 
 static void addAnyTypeKeyword(CodeCompletionResultSink &Sink, Type T) {
   CodeCompletionResultBuilder Builder(Sink, CodeCompletionResultKind::Keyword,
-                                      SemanticContextKind::None, {});
+                                      SemanticContextKind::None);
   Builder.setKeywordKind(CodeCompletionKeywordKind::None);
   Builder.addKeyword("Any");
   Builder.addTypeAnnotation(T, PrintOptions());
@@ -1040,7 +1040,7 @@ static void addPoundDirectives(CodeCompletionResultSink &Sink) {
               nullptr) {
         CodeCompletionResultBuilder Builder(Sink,
                                             CodeCompletionResultKind::Keyword,
-                                            SemanticContextKind::None, {});
+                                            SemanticContextKind::None);
         Builder.addBaseName(name);
         Builder.setKeywordKind(K);
         if (consumer)
@@ -1100,7 +1100,7 @@ static void addPlatformConditions(CodeCompletionResultSink &Sink) {
             Sink, CodeCompletionResultKind::Pattern,
             // FIXME: SemanticContextKind::CurrentModule is not correct.
             // Use 'None' (and fix prioritization) or introduce a new context.
-            SemanticContextKind::CurrentModule, {});
+            SemanticContextKind::CurrentModule);
         Builder.addFlair(CodeCompletionFlairBit::ExpressionSpecific);
         Builder.addBaseName(Name);
         Builder.addLeftParen();
@@ -1150,7 +1150,7 @@ static void addConditionalCompilationFlags(ASTContext &Ctx,
         Sink, CodeCompletionResultKind::Keyword,
         // FIXME: SemanticContextKind::CurrentModule is not correct.
         // Use 'None' (and fix prioritization) or introduce a new context.
-        SemanticContextKind::CurrentModule, {});
+        SemanticContextKind::CurrentModule);
     Builder.addFlair(CodeCompletionFlairBit::ExpressionSpecific);
     Builder.addTextChunk(Flag);
   }

lib/IDE/CodeCompletionResultBuilder.h

@@ -49,7 +49,6 @@ class CodeCompletionResultBuilder {
   SmallVector<CodeCompletionString::Chunk, 4> Chunks;
   llvm::PointerUnion<const ModuleDecl *, const clang::Module *>
       CurrentModule;
-  ExpectedTypeContext declTypeContext;
   bool Cancelled = false;
   ContextFreeNotRecommendedReason ContextFreeNotRecReason =
       ContextFreeNotRecommendedReason::None;
@@ -90,10 +89,8 @@ class CodeCompletionResultBuilder {
 public:
   CodeCompletionResultBuilder(CodeCompletionResultSink &Sink,
                               CodeCompletionResultKind Kind,
-                              SemanticContextKind SemanticContext,
-                              const ExpectedTypeContext &declTypeContext)
-      : Sink(Sink), Kind(Kind), SemanticContext(SemanticContext),
-        declTypeContext(declTypeContext) {}
+                              SemanticContextKind SemanticContext)
+      : Sink(Sink), Kind(Kind), SemanticContext(SemanticContext) {}
 
   ~CodeCompletionResultBuilder() {
     finishResult();