Merge branch 'apple:main' into fix-init-accessor-71578

li3zhen1 · web-flow · commit 008e58a8051e · 2024-06-17T19:39:59.000-07:00
diff --git a/lib/AST/ASTMangler.cpp b/lib/AST/ASTMangler.cpp
@@ -3766,8 +3766,9 @@ void ASTMangler::appendClosureEntity(const AbstractClosureExpr *closure) {
 
   auto type = closure->getType();
 
-  // FIXME: CodeCompletionResultBuilder calls printValueDeclUSR() but the
-  // closure hasn't been type checked yet.
+  // FIXME: We can end up with a null type here in the presence of invalid
+  // code; the type-checker currently isn't strict about producing typed
+  // expression nodes when it fails. Once we enforce that, we can remove this.
   if (!type)
     type = ErrorType::get(closure->getASTContext());
 
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -1768,6 +1768,8 @@ bool ExtensionDecl::hasValidParent() const {
   return getDeclContext()->canBeParentOfExtension();
 }
 
+/// Does the extension's generic signature impose additional generic requirements
+/// not stated on the extended nominal type itself?
 bool ExtensionDecl::isConstrainedExtension() const {
   auto nominal = getExtendedNominal();
   if (!nominal)
@@ -1786,12 +1788,26 @@ bool ExtensionDecl::isConstrainedExtension() const {
   return !typeSig->isEqual(extSig);
 }
 
+/// Is the extension written as an unconstrained extension? This is not the same
+/// as isConstrainedExtension() in the case where the extended nominal type has
+/// inverse requirements, because an extension of such a type introduces default
+/// conformance requirements unless they're suppressed on the extension.
+///
+/// enum Optional<Wrapped> where Wrapped: ~Copyable {}
+///
+/// extension Optional {}
+///   --> isConstrainedExtension(): true
+///   --> isWrittenWithConstraints(): false
+///
+/// extension Optional where Wrapped: ~Copyable {}
+///   --> isConstrainedExtension(): false
+///   --> isWrittenWithConstraints(): true
 bool ExtensionDecl::isWrittenWithConstraints() const {
   auto nominal = getExtendedNominal();
   if (!nominal)
     return false;
 
-  // If there's no generic signature, then it's written without constraints.
+  // If there's no generic signature, then it's unconstrained.
   CanGenericSignature extSig = getGenericSignature().getCanonicalSignature();
   if (!extSig)
     return false;
@@ -1808,37 +1824,18 @@ bool ExtensionDecl::isWrittenWithConstraints() const {
   SmallVector<InverseRequirement, 2> typeInverseReqs;
   typeSig->getRequirementsWithInverses(typeReqs, typeInverseReqs);
 
-  // If the (non-inverse) requirements are different between the extension and
+  // If the non-inverse requirements are different between the extension and
   // the original type, it's written with constraints.
-  if (extReqs.size() != typeReqs.size()) {
+  if (extReqs != typeReqs)
     return true;
-  }
-
-  // In case of equal number of constraints, we have to check the specific
-  // requirements. Extensions can end up with fewer requirements than the type
-  // extended, due to a same-type requirement in the extension.
-  //
-  // This mirrors the 'same' check in `ASTMangler::gatherGenericSignatureParts`
-  for (size_t i = 0; i < extReqs.size(); i++) {
-    if (extReqs[i] != typeReqs[i])
-      return true;
-  }
 
-  // If the type has no inverse requirements, there are no extra constraints
-  // to write.
-  if (typeInverseReqs.empty()) {
-    assert(extInverseReqs.empty() && "extension retroactively added inverse?");
-    return false;
-  }
-
-  // If the extension has no inverse requirements, then there are no constraints
-  // that need to be written down.
-  if (extInverseReqs.empty()) {
-    return false;
-  }
+  // If the extension has inverse requirements, then it's written with
+  // constraints.
+  if (!extInverseReqs.empty())
+    return true;
 
-  // We have inverses that need to be written out.
-  return true;
+  // Otherwise, the extension is written as an unconstrained extension.
+  return false;
 }
 
 bool ExtensionDecl::isInSameDefiningModule() const {
diff --git a/lib/IDE/CodeCompletionResultBuilder.cpp b/lib/IDE/CodeCompletionResultBuilder.cpp
@@ -36,6 +36,11 @@ static bool shouldCopyAssociatedUSRForDecl(const ValueDecl *VD) {
   if (VD->hasClangNode() && !VD->getClangDecl())
     return false;
 
+  // Avoid generating USRs for decls in local contexts, we cannot guarantee
+  // any parent closures will be type-checked, which is needed for mangling.
+  if (VD->getDeclContext()->getLocalContext())
+    return false;
+
   return true;
 }
 
diff --git a/lib/Macros/Sources/ObservationMacros/Availability.swift b/lib/Macros/Sources/ObservationMacros/Availability.swift
@@ -12,7 +12,6 @@
 import SwiftSyntax
 import SwiftSyntaxMacros
 import SwiftDiagnostics
-import SwiftOperators
 import SwiftSyntaxBuilder
 
 
diff --git a/lib/Macros/Sources/ObservationMacros/CMakeLists.txt b/lib/Macros/Sources/ObservationMacros/CMakeLists.txt
@@ -16,7 +16,6 @@ add_swift_macro_library(ObservationMacros
   ObservableMacro.swift
   SWIFT_DEPENDENCIES
     SwiftDiagnostics
-    SwiftOperators
     SwiftSyntaxBuilder
     SwiftSyntax
     SwiftSyntaxMacros
diff --git a/lib/Macros/Sources/ObservationMacros/Extensions.swift b/lib/Macros/Sources/ObservationMacros/Extensions.swift
@@ -12,7 +12,6 @@
 import SwiftSyntax
 import SwiftSyntaxMacros
 import SwiftDiagnostics
-import SwiftOperators
 import SwiftSyntaxBuilder
 
 extension VariableDeclSyntax {
diff --git a/lib/Macros/Sources/SwiftMacros/CMakeLists.txt b/lib/Macros/Sources/SwiftMacros/CMakeLists.txt
@@ -18,7 +18,6 @@ add_swift_macro_library(SwiftMacros
   TaskLocalMacro.swift
   SWIFT_DEPENDENCIES
     SwiftDiagnostics
-    SwiftOperators
     SwiftSyntax
     SwiftSyntaxBuilder
     SwiftSyntaxMacros
diff --git a/lib/Macros/Sources/SwiftMacros/DistributedResolvableMacro.swift b/lib/Macros/Sources/SwiftMacros/DistributedResolvableMacro.swift
@@ -12,7 +12,6 @@
 import SwiftSyntax
 import SwiftSyntaxMacros
 import SwiftDiagnostics
-import SwiftOperators
 import SwiftSyntaxBuilder
 
 /// Introduces:
diff --git a/lib/SILGen/SILGenEpilog.cpp b/lib/SILGen/SILGenEpilog.cpp
@@ -65,6 +65,7 @@ void SILGenFunction::prepareEpilog(
 
   if (errorType) {
     auto genericSig = DC->getGenericSignatureOfContext();
+    errorType = (*errorType)->getReducedType(genericSig);
     AbstractionPattern origErrorType = TypeContext
       ? *TypeContext->OrigType.getFunctionThrownErrorType()
       : AbstractionPattern(genericSig.getCanonicalSignature(),
diff --git a/lib/SILGen/SILGenProlog.cpp b/lib/SILGen/SILGenProlog.cpp
@@ -1539,6 +1539,8 @@ uint16_t SILGenFunction::emitBasicProlog(
   // Create the indirect result parameters.
   auto genericSig = DC->getGenericSignatureOfContext();
   resultType = resultType->getReducedType(genericSig);
+  if (errorType)
+    errorType = (*errorType)->getReducedType(genericSig);
 
   std::optional<AbstractionPattern> origClosureType;
   if (TypeContext) origClosureType = TypeContext->OrigType;
diff --git a/lib/SILOptimizer/Mandatory/MoveOnlyWrappedTypeEliminator.cpp b/lib/SILOptimizer/Mandatory/MoveOnlyWrappedTypeEliminator.cpp
@@ -180,6 +180,7 @@ struct SILMoveOnlyWrappedTypeEliminatorVisitor
   NO_UPDATE_NEEDED(MarkDependence)
   NO_UPDATE_NEEDED(DestroyAddr)
   NO_UPDATE_NEEDED(DeallocStack)
+  NO_UPDATE_NEEDED(DeallocBox)
   NO_UPDATE_NEEDED(Branch)
   NO_UPDATE_NEEDED(ExplicitCopyAddr)
   NO_UPDATE_NEEDED(CopyAddr)
diff --git a/lib/SILOptimizer/PassManager/PassPipeline.cpp b/lib/SILOptimizer/PassManager/PassPipeline.cpp
@@ -683,7 +683,14 @@ static void addPerfEarlyModulePassPipeline(SILPassPipelinePlan &P) {
 static void addHighLevelFunctionPipeline(SILPassPipelinePlan &P) {
   P.startPipeline("HighLevel,Function+EarlyLoopOpt",
                   true /*isFunctionPassPipeline*/);
-  P.addEagerSpecializer();
+
+  // Skip EagerSpecializer on embedded Swift, which already specializes
+  // everything. Otherwise this would create metatype references for functions
+  // with @_specialize attribute and those are incompatible with Emebdded Swift.
+  if (!P.getOptions().EmbeddedSwift) {
+    P.addEagerSpecializer();
+  }
+
   P.addObjCBridgingOptimization();
 
   addFunctionPasses(P, OptimizationLevelKind::HighLevel);
diff --git a/lib/Sema/SyntacticElementTarget.cpp b/lib/Sema/SyntacticElementTarget.cpp
@@ -303,9 +303,15 @@ bool SyntacticElementTarget::contextualTypeIsOnlyAHint() const {
 
 void SyntacticElementTarget::markInvalid() const {
   class InvalidationWalker : public ASTWalker {
+    ASTContext &Ctx;
+
+  public:
+    InvalidationWalker(ASTContext &ctx) : Ctx(ctx) {}
+
     PreWalkResult<Expr *> walkToExprPre(Expr *E) override {
-      // TODO: We ought to fill in ErrorTypes for expressions here; ultimately
-      // type-checking should always produce typed AST.
+      if (!E->getType())
+        E->setType(ErrorType::get(Ctx));
+
       return Action::Continue(E);
     }
 
@@ -321,7 +327,7 @@ void SyntacticElementTarget::markInvalid() const {
       return Action::VisitNodeIf(isa<PatternBindingDecl>(D));
     }
   };
-  InvalidationWalker walker;
+  InvalidationWalker walker(getDeclContext()->getASTContext());
   walk(walker);
 }
 
diff --git a/lib/Sema/TypeCheckConcurrency.cpp b/lib/Sema/TypeCheckConcurrency.cpp
@@ -2706,7 +2706,7 @@ namespace {
     PreWalkResult<Expr *> walkToExprPre(Expr *expr) override {
       // Skip expressions that didn't make it to solution application
       // because the constraint system diagnosed an error.
-      if (!expr->getType())
+      if (!expr->getType() || expr->getType()->hasError())
         return Action::SkipNode(expr);
 
       if (auto *openExistential = dyn_cast<OpenExistentialExpr>(expr)) {
diff --git a/lib/Sema/TypeCheckEffects.cpp b/lib/Sema/TypeCheckEffects.cpp
@@ -1283,7 +1283,7 @@ class ApplyClassifier {
     thrownValue = removeErasureToExistentialError(thrownValue);
 
     Type thrownType = thrownValue->getType();
-    if (!thrownType)
+    if (!thrownType || thrownType->hasError())
       return Classification::forInvalidCode();
 
     // FIXME: Add a potential effect reason for a throw site.
diff --git a/stdlib/public/Concurrency/AsyncSequence.swift b/stdlib/public/Concurrency/AsyncSequence.swift
@@ -81,7 +81,7 @@ public protocol AsyncSequence<Element, Failure> {
 
   /// The type of errors produced when iteration over the sequence fails.
   @available(SwiftStdlib 6.0, *)
-  associatedtype Failure: Error = AsyncIterator.Failure
+  associatedtype Failure: Error = any Error
       where AsyncIterator.Failure == Failure
 
   /// Creates the asynchronous iterator that produces elements of this
diff --git a/test/SILGen/typed_throws_generic.swift b/test/SILGen/typed_throws_generic.swift
@@ -378,3 +378,12 @@ struct GSF2<F: Error, T>: P2 {
 struct GSA<T>: P2 {
   typealias Failure = any Error
 }
+
+struct ReducedError<T: Error> {}
+
+extension ReducedError where T == MyError {
+  // CHECK-LABEL: sil hidden [ossa] @$s20typed_throws_generic12ReducedErrorVA2A02MyE0ORszrlE05throwfE0yyAEYKF : $@convention(method) (ReducedError<MyError>) -> @error MyError {
+  func throwMyError() throws(T) {
+    throw MyError.fail
+  }
+}
diff --git a/test/SILOptimizer/moveonly_type_eliminator.sil b/test/SILOptimizer/moveonly_type_eliminator.sil
@@ -578,3 +578,24 @@ bb0(%x : @owned $Klass):
   %retval = tuple ()
   return %retval : $()
 }
+
+// SILGen occasionally uses dealloc_box instead of destroy_value. dealloc_box is needed when we don't want to destroy
+// the contents of the box. It seems to happen with property wrappers.
+//
+// CHECK-LABEL: sil [ossa] @dealoc_box : $@convention(thin) (@owned Klass) -> () {
+// CHECK:           [[BOX:%.*]] = alloc_box [moveable_value_debuginfo] ${ var Klass }
+// CHECK:           dealloc_box [[BOX]] : ${ var Klass }
+// CHECK-LABEL: } // end sil function 'dealoc_box'
+sil [ossa] @dealoc_box : $@convention(thin) (@owned Klass) -> () {
+bb0(%x : @owned $Klass):
+  %box = alloc_box ${ var @moveOnly Klass }
+  %addr = project_box %box : ${ var @moveOnly Klass }, 0
+  %unwrapped_addr = moveonlywrapper_to_copyable_addr %addr : $*@moveOnly Klass
+  store %x to [init] %unwrapped_addr : $*Klass
+  debug_value %addr : $*@moveOnly Klass, var, name "s", argno 1, expr op_deref
+  destroy_addr %addr : $*@moveOnly Klass
+  debug_value undef : $*@moveOnly Klass, var, name "s", argno 1, expr op_deref
+  dealloc_box %box : ${ var @moveOnly Klass }
+  %retval = tuple ()
+  return %retval : $()
+}
diff --git a/test/SourceKit/CodeComplete/complete_local_decl.swift b/test/SourceKit/CodeComplete/complete_local_decl.swift
@@ -0,0 +1,30 @@
+// rdar://128294522 - Make sure we don't generate USRs for decls in local contexts.
+
+func test1() {
+  let loclVar = 0 // This typo is intentional; otherwise mangling applies a substitution for 'local'.
+  // RUN: %sourcekitd-test -req=complete -pos=%(line):3 %s -- %s | %FileCheck %s --check-prefix LOCAL_VAR
+  // LOCAL_VAR-NOT: key.associated_usrs: "s:{{.*}}loclVar{{.*}}"
+  // LOCAL_VAR:     key.name: "loclVar"
+  // LOCAL_VAR-NOT: key.associated_usrs: "s:{{.*}}loclVar{{.*}}"
+}
+
+func test2() {
+  let _ = {
+    struct S {
+      func nestedMethod() {
+        // RUN: %sourcekitd-test -req=complete -pos=%(line):3 %s -- %s | %FileCheck %s --check-prefix LOCAL_METHOD
+        // RUN: %sourcekitd-test -req=complete -pos=%(line+1):14 %s -- %s | %FileCheck %s --check-prefix LOCAL_METHOD
+        self.
+        // LOCAL_METHOD-NOT: key.associated_usrs: "s:{{.*}}nestedMethod{{.*}}"
+        // LOCAL_METHOD:     key.name: "nestedMethod()"
+        // LOCAL_METHOD-NOT: key.associated_usrs: "s:{{.*}}nestedMethod{{.*}}"
+      }
+    }
+  }
+}
+
+// Just to make sure 'key.associated_usrs' is produced for a non-local decl
+// so the above CHECK-NOT's are working. If this fails, make sure to update the
+// above checks too.
+// RUN: %sourcekitd-test -req=complete -pos=%(line):1 %s -- %s | %FileCheck %s --check-prefix NON_LOCAL
+// NON_LOCAL: key.associated_usrs: "s:{{.*}}test2{{.*}}"
diff --git a/test/SourceKit/CursorInfo/rdar129417672.swift b/test/SourceKit/CursorInfo/rdar129417672.swift
@@ -0,0 +1,19 @@
+// RUN: %sourcekitd-test -req=cursor -pos=12:11 %s -- %s
+
+private class MacroApplication<Context: MacroExpansionContext>: SyntaxRewriter {
+
+  override func visitAny(_ node: Syntax) -> Syntax? {
+    if var declSyntax = node.as(DeclSyntax.self),
+      let attributedNode = node.asProtocol(WithAttributesSyntax.self),
+      !attributedNode.attributes.isEmpty
+    {
+      for (attribute, spec) in attributesToRemove {
+        if let index = self.expandedAttributes.firstIndex(where: { expandedAttribute in
+          expandedAttribute.position == attribute.position
+        }) {
+        } else {
+        }
+      }
+    }
+  }
+}
diff --git a/test/embedded/specialize-attrs2.swift b/test/embedded/specialize-attrs2.swift
@@ -0,0 +1,20 @@
+// RUN: %target-run-simple-swift(-parse-as-library -Onone -enable-experimental-feature Embedded -runtime-compatibility-version none -wmo -Xfrontend -disable-objc-interop -Xlinker -dead_strip) | %FileCheck %s
+// RUN: %target-run-simple-swift(-parse-as-library -O -enable-experimental-feature Embedded -runtime-compatibility-version none -wmo -Xfrontend -disable-objc-interop -Xlinker -dead_strip) | %FileCheck %s
+// RUN: %target-run-simple-swift(-parse-as-library -Osize -enable-experimental-feature Embedded -runtime-compatibility-version none -wmo -Xfrontend -disable-objc-interop -Xlinker -dead_strip) | %FileCheck %s
+
+// REQUIRES: swift_in_compiler
+// REQUIRES: executable_test
+// REQUIRES: optimized_stdlib
+// REQUIRES: OS=macosx
+
+@main
+struct Main {
+  static func main() {
+    let chars: [Character] = ["a", "b", "c"]
+    let s = Substring.init(chars)
+    print(s)
+    print("OK!")
+  }
+}
+
+// CHECK: OK!
