Merge pull request #5220 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

benchmark/CMakeLists.txt

@@ -201,6 +201,7 @@ set(SWIFT_BENCH_MODULES
     single-source/WordCount
     single-source/XorLoop
     cxx-source/CreateObjects
+    cxx-source/CxxSetToCollection
     cxx-source/CxxVectorSum
     cxx-source/ReadAccessor
 )

benchmark/cxx-source/CxxSetToCollection.swift

@@ -0,0 +1,61 @@
+//===--- CxxSetToCollection.swift -----------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2012 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+// This is a benchmark that tracks how quickly Swift can convert a C++ set
+// to a Swift collection.
+
+import TestsUtils
+
+#if SWIFT_PACKAGE
+// FIXME: Needs fix for https://github.com/apple/swift/issues/61547.
+
+public let benchmarks = [BenchmarkInfo]()
+
+#else
+
+import CxxStdlibPerformance
+import Cxx
+
+public let benchmarks = [
+  BenchmarkInfo(
+    name: "CxxSetU32.to.Array",
+    runFunction: run_CxxSetOfU32_to_Array,
+    tags: [.validation, .bridging, .cxxInterop],
+    setUpFunction: makeSetOnce),
+  BenchmarkInfo(
+    name: "CxxSetU32.to.Set",
+    runFunction: run_CxxSetOfU32_to_Set,
+    tags: [.validation, .bridging, .cxxInterop],
+    setUpFunction: makeSetOnce),
+]
+
+func makeSetOnce() {
+  initSet(setSize)
+}
+
+let setSize = 1_000
+
+@inline(never)
+public func run_CxxSetOfU32_to_Array(_ n: Int) {
+  for _ in 0..<n {
+    blackHole(Array(set))
+  }
+}
+
+@inline(never)
+public func run_CxxSetOfU32_to_Set(_ n: Int) {
+  for _ in 0..<n {
+    blackHole(Set(set))
+  }
+}
+
+#endif

benchmark/scripts/Benchmark_Driver

@@ -627,16 +627,26 @@ class BenchmarkDoctor(object):
     @staticmethod
     def _constant_memory_use(measurements):
         select = BenchmarkDoctor._select
+        name = measurements["name"]
+
+        memory_uses = [
+            [r.mem_pages for r in i_series if r.mem_pages is not None]
+            for i_series in [select(measurements, num_iters=i) for i in [1, 2]]
+        ]
+        memory_uses = [m for m in memory_uses if m]
+        if not memory_uses:
+            BenchmarkDoctor.log_memory.info(
+                "unable to compute memory footprint of '%s'",
+                name,
+            )
+            return
+
         (min_i1, max_i1), (min_i2, max_i2) = [
             (min(memory_use), max(memory_use))
-            for memory_use in [
-                [r.mem_pages for r in i_series]
-                for i_series in [select(measurements, num_iters=i) for i in [1, 2]]
-            ]
+            for memory_use in memory_uses
         ]
         range_i1, range_i2 = max_i1 - min_i1, max_i2 - min_i2
         normal_range = 15  # pages
-        name = measurements["name"]
         more_info = False
 
         if abs(min_i1 - min_i2) > max(range_i1, range_i2, normal_range):

benchmark/utils/CxxTests/CxxStdlibPerformance.h

@@ -2,10 +2,13 @@
 
 #include <cstdint>
 #include <vector>
+#include <set>
 
 using VectorOfU32 = std::vector<uint32_t>;
+using SetOfU32 = std::set<uint32_t>;
 
 static inline VectorOfU32 vec;
+static inline SetOfU32 set;
 
 inline void initVector(size_t size) {
     if (!vec.empty()) {
@@ -17,11 +20,25 @@ inline void initVector(size_t size) {
     }
 }
 
+inline void initSet(size_t size) {
+    if (!set.empty()) {
+        return;
+    }
+    for (size_t i = 0; i < size; ++i) {
+        set.insert(uint32_t(i));
+    }
+}
+
 inline VectorOfU32 makeVector32(size_t size) {
     initVector(size);
     return vec;
 }
 
+inline SetOfU32 makeSet32(size_t size) {
+    initSet(size);
+    return set;
+}
+
 inline uint32_t testVector32Sum(size_t vectorSize, size_t iters) {
     auto vector = makeVector32(vectorSize);
     auto sum = uint32_t(0);

benchmark/utils/main.swift

@@ -51,6 +51,7 @@ import ClassArrayGetter
 import CodableTest
 import Combos
 import CreateObjects
+import CxxSetToCollection
 import CxxVectorSum
 import DataBenchmarks
 import DeadArray
@@ -237,6 +238,7 @@ register(CodableTest.benchmarks)
 register(Combos.benchmarks)
 register(ClassArrayGetter.benchmarks)
 register(CreateObjects.benchmarks)
+register(CxxSetToCollection.benchmarks)
 register(CxxVectorSum.benchmarks)
 register(DataBenchmarks.benchmarks)
 register(DeadArray.benchmarks)

docs/SIL.rst

@@ -6022,7 +6022,7 @@ an `inject_enum_addr`_ instruction::
   entry(%0 : $*AddressOnlyEnum, %1 : $*AddressOnlyType):
     // Store the data argument for the case.
     %2 = init_enum_data_addr %0 : $*AddressOnlyEnum, #AddressOnlyEnum.HasData!enumelt
-    copy_addr [take] %2 to [init] %1 : $*AddressOnlyType
+    copy_addr [take] %1 to [init] %2 : $*AddressOnlyType
     // Inject the tag.
     inject_enum_addr %0 : $*AddressOnlyEnum, #AddressOnlyEnum.HasData!enumelt
     return

include/swift-c/DependencyScan/DependencyScan.h

@@ -303,6 +303,9 @@ swiftscan_compiler_supported_features_query();
 //=== Target-Info Functions -----------------------------------------------===//
 SWIFTSCAN_PUBLIC swiftscan_string_ref_t
 swiftscan_compiler_target_info_query(swiftscan_scan_invocation_t invocation);
+SWIFTSCAN_PUBLIC swiftscan_string_ref_t
+swiftscan_compiler_target_info_query_v2(swiftscan_scan_invocation_t invocation,
+                                        const char *main_executable_path);
 
 //=== Scanner Functions ---------------------------------------------------===//
 

include/swift/AST/DiagnosticsSema.def

@@ -3351,6 +3351,14 @@ ERROR(attr_incompatible_with_non_final,none,
       "'%0' cannot be applied to a non-final %1",
       (DeclAttribute, DescriptiveDeclKind))
 
+ERROR(attr_incompatible_with_override,none,
+      "'%0' cannot be combined with 'override'",
+      (DeclAttribute))
+
+ERROR(attr_incompatible_with_objc,none,
+      "'%0' must not be used on an '@objc' %1",
+      (DeclAttribute, DescriptiveDeclKind))
+
 ERROR(final_not_on_accessors,none,
       "'final' cannot be applied to accessors, it must be put on the "
       "%select{var|let|subscript}0", (unsigned))
@@ -6696,7 +6704,7 @@ ERROR(concurrency_task_to_thread_model_global_actor_annotation,none,
       (TypeRepr*, StringRef))
 
 ERROR(moveOnly_not_allowed_here,none,
-      "'moveOnly' may only be applied to classes, structs, and enums", ())
+      "'moveOnly' only applies to structs or enums", ())
 ERROR(move_expression_not_passed_lvalue,none,
       "'move' can only be applied to lvalues", ())
 ERROR(borrow_expression_not_passed_lvalue,none,

include/swift/AST/MacroDeclaration.h

@@ -66,6 +66,14 @@ bool macroIntroducedNameRequiresArgument(MacroIntroducedDeclNameKind kind);
 StringRef getMacroIntroducedDeclNameString(
     MacroIntroducedDeclNameKind kind);
 
+class CustomAttr;
+
+/// Perform lookup to determine whether the given custom attribute refers to
+/// a macro declaration, and populate the \c macros vector with the lookup
+/// results that are attached macros.
+void findMacroForCustomAttr(CustomAttr *attr, DeclContext *dc,
+                            llvm::TinyPtrVector<ValueDecl *> &macros);
+
 class MacroIntroducedDeclName {
 public:
   using Kind = MacroIntroducedDeclNameKind;

include/swift/AST/PrintOptions.h

@@ -533,6 +533,16 @@ struct PrintOptions {
   /// parameter.
   bool PrintSpecializeAttributeWithAvailability = true;
 
+  /// Whether to always desugar array types from `[base_type]` to `Array<base_type>`
+  bool AlwaysDesugarArraySliceTypes = false;
+
+  /// Whether to always desugar dictionary types
+  /// from `[key_type:value_type]` to `Dictionary<key_type,value_type>`
+  bool AlwaysDesugarDictionaryTypes = false;
+
+  /// Whether to always desugar optional types from `base_type?` to `Optional<base_type>`
+  bool AlwaysDesugarOptionalTypes = false;
+
   /// \see ShouldQualifyNestedDeclarations
   enum class QualifyNestedDeclarations {
     Never,

include/swift/AST/TypeCheckRequests.h

@@ -3128,6 +3128,24 @@ class CheckRedeclarationRequest
                            evaluator::SideEffect) const;
 };
 
+/// Resolve a given custom attribute to an attached macro declaration.
+class ResolveAttachedMacroRequest
+    : public SimpleRequest<ResolveAttachedMacroRequest,
+                           MacroDecl *(CustomAttr *, DeclContext *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  MacroDecl *
+  evaluate(Evaluator &evaluator, CustomAttr *attr, DeclContext *dc) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 class ResolveTypeEraserTypeRequest
     : public SimpleRequest<ResolveTypeEraserTypeRequest,
                            Type (ProtocolDecl *, TypeEraserAttr *),

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -340,6 +340,9 @@ SWIFT_REQUEST(TypeChecker, PreCheckResultBuilderRequest,
 SWIFT_REQUEST(TypeChecker, ResolveImplicitMemberRequest,
               evaluator::SideEffect(NominalTypeDecl *, ImplicitMemberAction),
               Uncached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, ResolveAttachedMacroRequest,
+              MacroDecl *(CustomAttr *, DeclContext *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ResolveTypeEraserTypeRequest,
               Type(ProtocolDecl *, TypeEraserAttr *),
               SeparatelyCached, NoLocationInfo)

include/swift/Basic/DiagnosticOptions.h

@@ -32,7 +32,7 @@ class DiagnosticOptions {
     VerifyAndApplyFixes
   } VerifyMode = NoVerify;
 
-  enum FormattingStyle { LLVM, Swift };
+  enum FormattingStyle { LLVM, Swift, SwiftSyntax };
 
   /// Indicates whether to allow diagnostics for \c <unknown> locations if
   /// \c VerifyMode is not \c NoVerify.

include/swift/Basic/Features.def

@@ -103,6 +103,7 @@ EXPERIMENTAL_FEATURE(VariadicGenerics, false)
 EXPERIMENTAL_FEATURE(NamedOpaqueTypes, false)
 EXPERIMENTAL_FEATURE(FlowSensitiveConcurrencyCaptures, false)
 EXPERIMENTAL_FEATURE(MoveOnly, false)
+EXPERIMENTAL_FEATURE(MoveOnlyClasses, false)
 EXPERIMENTAL_FEATURE(OneWayClosureParameters, false)
 EXPERIMENTAL_FEATURE(TypeWitnessSystemInference, false)
 EXPERIMENTAL_FEATURE(LayoutPrespecialization, false)

include/swift/Basic/LangOptions.h

@@ -366,7 +366,7 @@ namespace swift {
 
     /// Enable early skipping deserialization of decls that are marked as
     /// unsafe to read.
-    bool EnableDeserializationSafety = false;
+    bool EnableDeserializationSafety = true;
 
     /// Whether to enable the new operator decl and precedencegroup lookup
     /// behavior. This is a staging flag, and will be removed in the future.

include/swift/DependencyScan/DependencyScanningTool.h

@@ -48,7 +48,8 @@ class DependencyScannerDiagnosticCollectingConsumer : public DiagnosticConsumer
 
 /// Given a set of arguments to a print-target-info frontend tool query, produce the
 /// JSON target info.
-llvm::ErrorOr<swiftscan_string_ref_t> getTargetInfo(ArrayRef<const char *> Command);
+llvm::ErrorOr<swiftscan_string_ref_t> getTargetInfo(ArrayRef<const char *> Command,
+                                                    const char *main_executable_path);
 
 /// The high-level implementation of the dependency scanner that runs on
 /// an individual worker thread.

include/swift/Frontend/PrintingDiagnosticConsumer.h

@@ -45,6 +45,12 @@ class PrintingDiagnosticConsumer : public DiagnosticConsumer {
   SmallVector<std::string, 1> BufferedEducationalNotes;
   bool SuppressOutput = false;
 
+  /// swift-syntax rendering
+  void *queuedDiagnostics = nullptr;
+  void *queuedSourceFile = nullptr;
+  unsigned queuedDiagnosticsBufferID;
+  StringRef queuedBufferName;
+
 public:
   PrintingDiagnosticConsumer(llvm::raw_ostream &stream = llvm::errs());
   ~PrintingDiagnosticConsumer();