Merge pull request #5435 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

benchmark/CMakeLists.txt

@@ -121,6 +121,7 @@ set(SWIFT_BENCH_MODULES
     single-source/NSDictionaryCastToSwift
     single-source/NSErrorTest
     single-source/NSStringConversion
+    single-source/NaiveRangeReplaceableCollectionConformance
     single-source/NibbleSort
     single-source/NIOChannelPipeline
     single-source/NopDeinit

benchmark/single-source/NaiveRangeReplaceableCollectionConformance.swift

@@ -0,0 +1,101 @@
+//===--- NaiveRangeReplaceableCollectionConformance.swift -----------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2023 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
+
+var contiguous:[UInt8] = []
+
+public let benchmarks = [
+    BenchmarkInfo(name: "NaiveRRC.append.largeContiguous",
+                  runFunction: runAppendLargeContiguous,
+                  tags: [.validation, .api],
+                  setUpFunction: { contiguous = [UInt8](repeating: 7, count: 1_000) }),
+    BenchmarkInfo(name: "NaiveRRC.append.smallContiguousRepeated",
+                  runFunction: runAppendSmallContiguousRepeatedly,
+                  tags: [.validation, .api],
+                  setUpFunction: { contiguous = [UInt8](repeating: 7, count: 1) }),
+    BenchmarkInfo(name: "NaiveRRC.init.largeContiguous",
+                  runFunction: runInitLargeContiguous,
+                  tags: [.validation, .api],
+                  setUpFunction: { contiguous = [UInt8](repeating: 7, count: 1_000) })
+]
+
+struct NaiveRRC : RangeReplaceableCollection {
+  
+  var storage:[UInt8] = []
+  
+  init() {}
+  
+  func index(after i: Int) -> Int {
+    i + 1
+  }
+  
+  func index(before i: Int) -> Int {
+    i - 1
+  }
+  
+  var startIndex: Int {
+    0
+  }
+  
+  var endIndex: Int {
+    count
+  }
+  
+  var count: Int {
+    storage.count
+  }
+  
+  subscript(position: Int) -> UInt8 {
+    get {
+      storage[position]
+    }
+    set(newValue) {
+      storage[position] = newValue
+    }
+  }
+  
+  mutating func replaceSubrange(_ subrange: Range<Int>, with newElements: some Collection<UInt8>) {
+    storage.replaceSubrange(subrange, with: newElements)
+  }
+  
+  mutating func reserveCapacity(_ n: Int) {
+    storage.reserveCapacity(n)
+  }
+}
+
+@inline(never)
+public func runAppendLargeContiguous(N: Int) {
+  for _ in 1...N {
+    var rrc = NaiveRRC()
+    rrc.append(contentsOf: contiguous)
+    blackHole(rrc)
+  }
+}
+
+@inline(never)
+public func runAppendSmallContiguousRepeatedly(N: Int) {
+  for _ in 1...N {
+    var rrc = NaiveRRC()
+    for _ in 1...5_000 {
+      rrc.append(contentsOf: contiguous)
+    }
+    blackHole(rrc)
+  }
+}
+
+@inline(never)
+public func runInitLargeContiguous(N: Int) {
+  for _ in 1...N {
+    blackHole(NaiveRRC(contiguous))
+  }
+}

benchmark/utils/main.swift

@@ -112,6 +112,7 @@ import Memset
 import MirrorTest
 import MonteCarloE
 import MonteCarloPi
+import NaiveRangeReplaceableCollectionConformance
 import NibbleSort
 import NIOChannelPipeline
 import NSDictionaryCastToSwift
@@ -303,6 +304,7 @@ register(Memset.benchmarks)
 register(MirrorTest.benchmarks)
 register(MonteCarloE.benchmarks)
 register(MonteCarloPi.benchmarks)
+register(NaiveRangeReplaceableCollectionConformance.benchmarks)
 register(NSDictionaryCastToSwift.benchmarks)
 register(NSErrorTest.benchmarks)
 #if canImport(Darwin)

include/swift/AST/DiagnosticsSema.def

@@ -7143,6 +7143,8 @@ ERROR(moveonly_cannot_conform_to_type, none,
      (DescriptiveDeclKind, DeclName, Type))
 ERROR(moveonly_parameter_missing_ownership, none,
       "noncopyable parameter must specify its ownership", ())
+ERROR(moveonly_parameter_subscript_unsupported, none,
+      "subscripts cannot have noncopyable parameters yet", ())
 NOTE(moveonly_parameter_ownership_suggestion, none,
       "add '%0' %1", (StringRef, StringRef))
 ERROR(ownership_specifier_copyable,none,

include/swift/IDE/CodeCompletionResult.h

@@ -228,6 +228,9 @@ enum class CompletionKind : uint8_t {
   ForEachPatternBeginning,
   TypeAttrBeginning,
   OptionalBinding,
+
+  /// Completion after `~` in an inheritance clause.
+  WithoutConstraintType
 };
 
 enum class CodeCompletionDiagnosticSeverity : uint8_t {

include/swift/IDE/CompletionLookup.h

@@ -620,6 +620,8 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
   void getStmtLabelCompletions(SourceLoc Loc, bool isContinue);
 
   void getOptionalBindingCompletions(SourceLoc Loc);
+
+  void getWithoutConstraintTypes();
 };
 
 } // end namespace ide

include/swift/Parse/IDEInspectionCallbacks.h

@@ -261,6 +261,8 @@ class CodeCompletionCallbacks {
   virtual void completeTypeAttrBeginning() {};
 
   virtual void completeOptionalBinding(){};
+
+  virtual void completeWithoutConstraintType(){};
 };
 
 class DoneParsingCallback {

lib/AST/ASTScopeCreation.cpp

@@ -100,13 +100,14 @@ class ScopeCreator final : public ASTAllocated<ScopeCreator> {
     ASTScopeAssert(expr,
                  "If looking for closures, must have an expression to search.");
 
-    /// AST walker that finds top-level closures in an expression.
-    class ClosureFinder : public ASTWalker {
+    /// AST walker that finds nested scopes in expressions. This handles both
+    /// closures and if/switch expressions.
+    class NestedExprScopeFinder : public ASTWalker {
       ScopeCreator &scopeCreator;
       ASTScopeImpl *parent;
 
     public:
-      ClosureFinder(ScopeCreator &scopeCreator, ASTScopeImpl *parent)
+      NestedExprScopeFinder(ScopeCreator &scopeCreator, ASTScopeImpl *parent)
           : scopeCreator(scopeCreator), parent(parent) {}
 
       PreWalkResult<Expr *> walkToExprPre(Expr *E) override {
@@ -122,6 +123,13 @@ class ScopeCreator final : public ASTAllocated<ScopeCreator> {
                   parent, capture);
           return Action::SkipChildren(E);
         }
+
+        // If we have a single value statement expression, we need to add any
+        // scopes in the underlying statement.
+        if (auto *SVE = dyn_cast<SingleValueStmtExpr>(E)) {
+          scopeCreator.addToScopeTree(SVE->getStmt(), parent);
+          return Action::SkipChildren(E);
+        }
         return Action::Continue(E);
       }
       PreWalkResult<Stmt *> walkToStmtPre(Stmt *S) override {
@@ -148,7 +156,7 @@ class ScopeCreator final : public ASTAllocated<ScopeCreator> {
       }
     };
 
-    expr->walk(ClosureFinder(*this, parent));
+    expr->walk(NestedExprScopeFinder(*this, parent));
   }
 
 public:
@@ -518,11 +526,6 @@ class NodeAdder
     if (!expr)
       return p;
 
-    // If we have a single value statement expression, we expand scopes based
-    // on the underlying statement.
-    if (auto *SVE = dyn_cast<SingleValueStmtExpr>(expr))
-      return visit(SVE->getStmt(), p, scopeCreator);
-
     scopeCreator.addExprToScopeTree(expr, p);
     return p;
   }

lib/AST/Decl.cpp

@@ -5416,11 +5416,12 @@ NominalTypeDecl::getExecutorLegacyUnownedEnqueueFunction() const {
 
     if (auto *funcDecl = dyn_cast<AbstractFunctionDecl>(candidate)) {
       auto params = funcDecl->getParameters();
-
       if (params->size() != 1)
         continue;
 
-      if (params->get(0)->getType()->isEqual(unownedJobDecl->getDeclaredInterfaceType())) {
+      auto param = params->get(0);
+      if (param->getSpecifier() == ParamSpecifier::LegacyOwned ||
+          param->getSpecifier() == ParamSpecifier::Consuming) {
         return funcDecl;
       }
     }

lib/AST/GenericSignature.cpp

@@ -724,16 +724,16 @@ Type GenericSignatureImpl::getDependentUpperBounds(Type type) const {
           argTypes.push_back(reducedType);
       }
 
-      // We should have either constrained all primary associated types,
-      // or none of them.
-      if (!argTypes.empty()) {
-        if (argTypes.size() != primaryAssocTypes.size()) {
-          llvm::errs() << "Not all primary associated types constrained?\n";
-          llvm::errs() << "Interface type: " << type << "\n";
-          llvm::errs() << GenericSignature(this) << "\n";
-          abort();
-        }
-
+      // If we have constrained all primary associated types, create a
+      // parameterized protocol type. During code completion, we might call
+      // `getExistentialType` (which calls this method) on a generic parameter
+      // that doesn't have all parameters specified, e.g. to get a consise
+      // description of the parameter type to the following function.
+      //
+      // func foo<P: Publisher>(p: P) where P.Failure == Never
+      //
+      // In that case just add the base type in the default branch below.
+      if (argTypes.size() == primaryAssocTypes.size()) {
         types.push_back(ParameterizedProtocolType::get(ctx, baseType, argTypes));
         continue;
       }

lib/AST/Type.cpp

@@ -189,7 +189,7 @@ bool TypeBase::isMarkerExistential() {
 }
 
 bool TypeBase::isPureMoveOnly() {
-  if (auto *nom = getNominalOrBoundGenericNominal())
+  if (auto *nom = getAnyNominal())
     return nom->isMoveOnly();
 
   // if any components of the tuple are move-only, then the tuple is move-only.

lib/ASTGen/CMakeLists.txt

@@ -32,5 +32,6 @@ add_pure_swift_host_library(swiftASTGen STATIC
     SwiftSyntax::SwiftParserDiagnostics
     SwiftSyntax::SwiftSyntax
     SwiftSyntax::SwiftSyntaxMacros
+    SwiftSyntax::SwiftSyntaxMacroExpansion
     swiftLLVMJSON
 )

lib/ASTGen/Package.swift

@@ -37,10 +37,10 @@ let package = Package(
         .product(name: "SwiftOperators", package: "swift-syntax"),
         .product(name: "SwiftParser", package: "swift-syntax"),
         .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
+        .product(name: "SwiftSyntaxMacroExpansion", package: "swift-syntax"),
         "swiftLLVMJSON"
       ],
       path: "Sources/ASTGen",
-      exclude: ["CMakeLists.txt"],
       swiftSettings: swiftSetttings
     ),
     .target(