Merge pull request #2898 from swiftwasm/main

[pull] swiftwasm from main

Author: MaxDesiatov

benchmark/CMakeLists.txt

@@ -158,6 +158,7 @@ set(SWIFT_BENCH_MODULES
     single-source/RemoveWhere
     single-source/ReversedCollections
     single-source/RomanNumbers
+    single-source/SIMDRandomMask
     single-source/SIMDReduceInteger
     single-source/SequenceAlgos
     single-source/SetTests

benchmark/single-source/SIMDRandomMask.swift

@@ -0,0 +1,92 @@
+//===--- SIMDRandomMask.swift ---------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2021 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
+//
+//===----------------------------------------------------------------------===//
+
+import TestsUtils
+
+public let SIMDRandomMask = [
+  BenchmarkInfo(
+    name: "SIMDRandomMask.Int8x16",
+    runFunction: run_SIMDRandomMaskInt8x16,
+    tags: [.validation, .SIMD]
+  ),
+  BenchmarkInfo(
+    name: "SIMDRandomMask.Int8x64",
+    runFunction: run_SIMDRandomMaskInt8x64,
+    tags: [.validation, .SIMD]
+  ),
+  BenchmarkInfo(
+    name: "SIMDRandomMask.Int64x2",
+    runFunction: run_SIMDRandomMaskInt64x2,
+    tags: [.validation, .SIMD]
+  ),
+  BenchmarkInfo(
+    name: "SIMDRandomMask.Int64x8",
+    runFunction: run_SIMDRandomMaskInt64x8,
+    tags: [.validation, .SIMD]
+  ),
+  BenchmarkInfo(
+    name: "SIMDRandomMask.Int64x64",
+    runFunction: run_SIMDRandomMaskInt64x64,
+    tags: [.validation, .SIMD]
+  )
+]
+
+@inline(never)
+public func run_SIMDRandomMaskInt8x16(_ N: Int) {
+  var g = SplitMix64(seed: 0)
+  var accum = SIMDMask<SIMD16<Int8>>()
+  for _ in 0 ..< 10000*N {
+    accum .^= SIMDMask.random(using: &g)
+  }
+  blackHole(accum)
+}
+
+@inline(never)
+public func run_SIMDRandomMaskInt8x64(_ N: Int) {
+  var g = SplitMix64(seed: 0)
+  var accum = SIMDMask<SIMD64<Int8>>()
+  for _ in 0 ..< 10000*N {
+    accum .^= SIMDMask.random(using: &g)
+  }
+  blackHole(accum)
+}
+
+@inline(never)
+public func run_SIMDRandomMaskInt64x2(_ N: Int) {
+  var g = SplitMix64(seed: 0)
+  var accum = SIMDMask<SIMD2<Int64>>()
+  for _ in 0 ..< 10000*N {
+    accum .^= SIMDMask.random(using: &g)
+  }
+  blackHole(accum)
+}
+
+@inline(never)
+public func run_SIMDRandomMaskInt64x8(_ N: Int) {
+  var g = SplitMix64(seed: 0)
+  var accum = SIMDMask<SIMD8<Int64>>()
+  for _ in 0 ..< 10000*N {
+    accum .^= SIMDMask.random(using: &g)
+  }
+  blackHole(accum)
+}
+
+@inline(never)
+public func run_SIMDRandomMaskInt64x64(_ N: Int) {
+  var g = SplitMix64(seed: 0)
+  var accum = SIMDMask<SIMD64<Int64>>()
+  for _ in 0 ..< 10000*N {
+    accum .^= SIMDMask.random(using: &g)
+  }
+  blackHole(accum)
+}
+ 

benchmark/utils/main.swift

@@ -156,6 +156,7 @@ import ReduceInto
 import RemoveWhere
 import ReversedCollections
 import RomanNumbers
+import SIMDRandomMask
 import SIMDReduceInteger
 import SequenceAlgos
 import SetTests
@@ -353,6 +354,7 @@ registerBenchmark(ReduceInto)
 registerBenchmark(RemoveWhere)
 registerBenchmark(ReversedCollections)
 registerBenchmark(RomanNumbers)
+registerBenchmark(SIMDRandomMask)
 registerBenchmark(SIMDReduceInteger)
 registerBenchmark(SequenceAlgos)
 registerBenchmark(SetTests)

include/swift/ABI/TaskStatus.h

@@ -254,7 +254,7 @@ class TaskGroupTaskStatusRecord : public TaskStatusRecord {
 /// subsequently used.
 class CancellationNotificationStatusRecord : public TaskStatusRecord {
 public:
-  using FunctionType = void (void *);
+  using FunctionType = SWIFT_CC(swift) void (SWIFT_CONTEXT void *);
 
 private:
   FunctionType * __ptrauth_swift_cancellation_notification_function Function;

include/swift/AST/ActorIsolation.h

@@ -24,14 +24,17 @@ class raw_ostream;
 }
 
 namespace swift {
-class ClassDecl;
+class DeclContext;
+class NominalTypeDecl;
 class SubstitutionMap;
-class Type;
 
 /// Determine whether the given types are (canonically) equal, declared here
 /// to avoid having to include Types.h.
 bool areTypesEqual(Type type1, Type type2);
 
+/// Determine whether the given type is suitable as a concurrent value type.
+bool isSendableType(const DeclContext *dc, Type type);
+
 /// Describes the actor isolation of a given declaration, which determines
 /// the actors with which it can interact.
 class ActorIsolation {

include/swift/AST/Attr.h

@@ -110,12 +110,15 @@ class DeclAttribute : public AttributeBase {
   union {
     uint64_t OpaqueBits;
 
-    SWIFT_INLINE_BITFIELD_BASE(DeclAttribute, bitmax(NumDeclAttrKindBits,8)+1+1,
+    SWIFT_INLINE_BITFIELD_BASE(DeclAttribute, bitmax(NumDeclAttrKindBits,8)+1+1+1,
       Kind : bitmax(NumDeclAttrKindBits,8),
       // Whether this attribute was implicitly added.
       Implicit : 1,
 
-      Invalid : 1
+      Invalid : 1,
+
+      /// Whether the attribute was created by an access note.
+      AddedByAccessNote : 1
     );
 
     SWIFT_INLINE_BITFIELD(ObjCAttr, DeclAttribute, 1+1+1,
@@ -191,6 +194,7 @@ class DeclAttribute : public AttributeBase {
     Bits.DeclAttribute.Kind = static_cast<unsigned>(DK);
     Bits.DeclAttribute.Implicit = Implicit;
     Bits.DeclAttribute.Invalid = false;
+    Bits.DeclAttribute.AddedByAccessNote = false;
   }
 
 private:
@@ -329,6 +333,18 @@ class DeclAttribute : public AttributeBase {
 
   bool isValid() const { return !isInvalid(); }
 
+
+  /// Determine whether this attribute was added by an access note. If it was,
+  /// the compiler will generally recover from failures involving this attribute
+  /// as though it is not present.
+  bool getAddedByAccessNote() const {
+    return Bits.DeclAttribute.AddedByAccessNote;
+  }
+
+  void setAddedByAccessNote(bool accessNote = true) {
+    Bits.DeclAttribute.AddedByAccessNote = accessNote;
+  }
+
   /// Returns the address of the next pointer field.
   /// Used for object deserialization.
   DeclAttribute **getMutableNext() {

include/swift/AST/Decl.h

@@ -1682,6 +1682,62 @@ class PatternBindingDecl final : public Decl,
     return const_cast<PatternBindingDecl*>(this)->getMutablePatternList();
   }
 
+  /// Clean up walking the initializers for the pattern
+  class InitIterator {
+
+    const PatternBindingDecl &decl;
+    unsigned currentPatternEntryIndex;
+
+    void next() { ++currentPatternEntryIndex; }
+
+  public:
+    using value_type = Expr *;
+    using pointer = value_type;
+    using reference = value_type;
+    using difference_type = unsigned;
+
+    InitIterator(const PatternBindingDecl &decl, unsigned start = 0)
+        : decl(decl), currentPatternEntryIndex(start) {}
+
+    InitIterator &operator++() {
+      next();
+      return *this;
+    }
+
+    InitIterator operator++(int) {
+      InitIterator newIterator(decl, currentPatternEntryIndex);
+      newIterator.next();
+      return newIterator;
+    }
+
+    pointer operator->() { return decl.getInit(currentPatternEntryIndex); }
+
+    pointer operator*() { return decl.getInit(currentPatternEntryIndex); }
+
+    difference_type operator-(const InitIterator &other) {
+      return currentPatternEntryIndex - other.currentPatternEntryIndex;
+    }
+
+    bool operator==(const InitIterator &other) const {
+      return &decl == &other.decl &&
+             currentPatternEntryIndex == other.currentPatternEntryIndex;
+    }
+
+    bool operator!=(const InitIterator &other) const {
+      return !(*this == other);
+    }
+  };
+
+  InitIterator beginInits() const { return InitIterator(*this); }
+
+  InitIterator endInits() const {
+    return InitIterator(*this, getNumPatternEntries());
+  }
+
+  llvm::iterator_range<InitIterator> initializers() const {
+    return llvm::make_range(beginInits(), endInits());
+  }
+
   void setInitStringRepresentation(unsigned i, StringRef str) {
     getMutablePatternList()[i].setInitStringRepresentation(str);
   }

include/swift/AST/DiagnosticsSema.def

@@ -3377,6 +3377,9 @@ ERROR(attr_completion_handler_async_ambiguous_function,none,
 ERROR(attr_completion_handler_async_no_suitable_function,none,
       "no corresponding async function named %0", (DeclNameRef))
 
+WARNING(warn_use_async_alternative,none,
+        "consider using asynchronous alternative function",())
+
 //------------------------------------------------------------------------------
 // MARK: Type Check Expressions
 //------------------------------------------------------------------------------
@@ -4311,6 +4314,8 @@ ERROR(asynchandler_noescape_closure_parameter,none,
 ERROR(asynchandler_mutating,none,
       "'@asyncHandler' function cannot be 'mutating'",
       ())
+ERROR(asynchandler_removed,none,
+      "'@asyncHandler' has been removed from the language", ())
 
 ERROR(objc_ambiguous_async_convention,none,
       "%0 overrides or implements protocol requirements for Objective-C "
@@ -4827,7 +4832,7 @@ ERROR(objc_extension_not_class,none,
       "'@objc' can only be applied to an extension of a class", ())
 
 // If you change this, also change enum ObjCReason
-#define OBJC_ATTR_SELECT "select{marked @_cdecl|marked dynamic|marked @objc|marked @IBOutlet|marked @IBAction|marked @IBSegueAction|marked @NSManaged|a member of an @objc protocol|implicitly @objc|an @objc override|an implementation of an @objc requirement|marked @IBInspectable|marked @GKInspectable|in an @objc extension of a class (without @nonobjc)}"
+#define OBJC_ATTR_SELECT "select{marked @_cdecl|marked dynamic|marked @objc|marked @IBOutlet|marked @IBAction|marked @IBSegueAction|marked @NSManaged|a member of an @objc protocol|implicitly @objc|an @objc override|an implementation of an @objc requirement|marked @IBInspectable|marked @GKInspectable|in an @objc extension of a class (without @nonobjc)|marked @objc by an access note}"
 
 WARNING(attribute_meaningless_when_nonobjc,none,
         "'@%0' attribute is meaningless on a property that cannot be "

include/swift/AST/GenericSignature.h

@@ -362,8 +362,6 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   /// Return the canonical version of the given type under this generic
   /// signature.
   CanType getCanonicalTypeInContext(Type type) const;
-  CanType getCanonicalTypeInContext(Type type,
-                                    GenericSignatureBuilder &builder) const;
 
   bool isCanonicalTypeInContext(Type type) const;
   bool isCanonicalTypeInContext(Type type,

include/swift/AST/GenericSignatureBuilder.h

@@ -270,6 +270,7 @@ class GenericSignatureBuilder {
     struct CachedNestedType {
       unsigned numConformancesPresent;
       CanType superclassPresent;
+      CanType concreteTypePresent;
       llvm::TinyPtrVector<TypeDecl *> types;
     };
 
@@ -613,6 +614,10 @@ class GenericSignatureBuilder {
   /// because the type \c Dictionary<K,V> cannot be formed without it.
   void inferRequirements(ModuleDecl &module, ParameterList *params);
 
+  GenericSignature rebuildSignatureWithoutRedundantRequirements(
+                      bool allowConcreteGenericParams,
+                      bool buildingRequirementSignature) &&;
+
   /// Finalize the set of requirements and compute the generic
   /// signature.
   ///
@@ -793,6 +798,13 @@ class GenericSignatureBuilder {
   /// Simplify the given dependent type down to its canonical representation.
   Type getCanonicalTypeParameter(Type type);
 
+  /// Replace any non-canonical dependent types in the given type with their
+  /// canonical representation. This is not a canonical type in the AST sense;
+  /// type sugar is preserved. The GenericSignature::getCanonicalTypeInContext()
+  /// method combines this with a subsequent getCanonicalType() call.
+  Type getCanonicalTypeInContext(Type type,
+                            TypeArrayView<GenericTypeParamType> genericParams);
+
   /// Verify the correctness of the given generic signature.
   ///
   /// This routine will test that the given generic signature is both minimal

include/swift/AST/TypeCheckRequests.h

@@ -2936,6 +2936,26 @@ class ConditionalRequirementsRequest
   bool isCached() const { return true; }
 };
 
+class TypeCheckCompletionHandlerAsyncAttrRequest
+    : public SimpleRequest<TypeCheckCompletionHandlerAsyncAttrRequest,
+                           bool(AbstractFunctionDecl *,
+                                CompletionHandlerAsyncAttr *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  bool evaluate(Evaluator &evaluator,
+                AbstractFunctionDecl *attachedFucntionDecl,
+                CompletionHandlerAsyncAttr *attr) const;
+
+public:
+  // Caching
+  bool isCached() const { return true; }
+};
+
 void simple_display(llvm::raw_ostream &out, Type value);
 void simple_display(llvm::raw_ostream &out, const TypeRepr *TyR);
 void simple_display(llvm::raw_ostream &out, ImplicitMemberAction action);

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -323,3 +323,6 @@ SWIFT_REQUEST(TypeChecker, SynthesizeMainFunctionRequest,
 SWIFT_REQUEST(TypeChecker, GetImplicitSendableRequest,
               NormalProtocolConformance *(NominalTypeDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, TypeCheckCompletionHandlerAsyncAttrRequest,
+              bool (AbstractFunctionDecl *, CompletionHandlerAsyncAttr *),
+              Cached, NoLocationInfo)

include/swift/Basic/FileTypes.def

@@ -83,6 +83,8 @@ TYPE("index-unit-output-path", IndexUnitOutputPath,    "",                "")
 TYPE("yaml-opt-record",     YAMLOptRecord,             "opt.yaml",        "")
 TYPE("bitstream-opt-record",BitstreamOptRecord,        "opt.bitstream",   "")
 
+TYPE("symbol-graph-output-path", SymbolGraphOutputPath, "",               "")
+
 // Overlay files declare wrapper modules, called "separately-imported overlays",
 // that should be automatically imported when a particular module is imported.
 // Cross-import directories conditionalize overlay files so they only take

include/swift/Basic/LangOptions.h

@@ -250,6 +250,9 @@ namespace swift {
     /// Enable experimental concurrency model.
     bool EnableExperimentalConcurrency = false;
 
+    /// Enable experimental asyncHandler support.
+    bool EnableExperimentalAsyncHandler = false;
+
     /// Enable experimental flow-sensitive concurrent captures.
     bool EnableExperimentalFlowSensitiveConcurrentCaptures = false;