Merge pull request #4751 from swiftwasm/release/5.7

kateinoigakukun · web-flow · commit 66cbff9e2095 · 2022-08-09T15:58:38.000+09:00
[pull] swiftwasm-release/5.7 from release/5.7
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -5430,6 +5430,20 @@ class VarDecl : public AbstractStorageDecl {
   /// is provided first.
   llvm::TinyPtrVector<CustomAttr *> getAttachedPropertyWrappers() const;
 
+  /// Retrieve the outermost property wrapper attribute associated with
+  /// this declaration. For example:
+  ///
+  /// \code
+  /// @A @B @C var <name>: Bool = ...
+  /// \endcode
+  ///
+  /// The outermost attribute in this case is `@A` and it has
+  /// complete wrapper type `A<B<C<Bool>>>`.
+  CustomAttr *getOutermostAttachedPropertyWrapper() const {
+    auto wrappers = getAttachedPropertyWrappers();
+    return wrappers.empty() ? nullptr : wrappers.front();
+  }
+
   /// Whether this property has any attached property wrappers.
   bool hasAttachedPropertyWrapper() const;
 
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -6532,7 +6532,7 @@ bool VarDecl::hasExternalPropertyWrapper() const {
     return true;
 
   // Wrappers with attribute arguments are always implementation-detail.
-  if (getAttachedPropertyWrappers().front()->hasArgs())
+  if (getOutermostAttachedPropertyWrapper()->hasArgs())
     return false;
 
   auto wrapperInfo = getAttachedPropertyWrapperTypeInfo(0);
diff --git a/lib/AST/ProtocolConformance.cpp b/lib/AST/ProtocolConformance.cpp
@@ -1608,8 +1608,22 @@ bool ProtocolConformance::isCanonical() const {
 
   switch (getKind()) {
   case ProtocolConformanceKind::Self:
-  case ProtocolConformanceKind::Normal:
+  case ProtocolConformanceKind::Normal: {
+    return true;
+  }
   case ProtocolConformanceKind::Builtin: {
+    // Check that the generic signature of the conformance is canonical.
+    auto builtinConformance = cast<BuiltinProtocolConformance>(this);
+    if (builtinConformance->getGenericSignature()
+        && !builtinConformance->getGenericSignature()->isCanonical()) {
+      return false;
+    }
+    // Check that the satisfied conditional requirements are canonical.
+    for (auto &requirement : builtinConformance->getConditionalRequirements()) {
+      if (!requirement.isCanonical()) {
+        return false;
+      }
+    }
     return true;
   }
   case ProtocolConformanceKind::Inherited: {
@@ -1638,11 +1652,25 @@ ProtocolConformance *ProtocolConformance::getCanonicalConformance() {
 
   switch (getKind()) {
   case ProtocolConformanceKind::Self:
-  case ProtocolConformanceKind::Normal:
-  case ProtocolConformanceKind::Builtin: {
+  case ProtocolConformanceKind::Normal: {
     // Root conformances are always canonical by construction.
     return this;
   }
+  case ProtocolConformanceKind::Builtin: {
+    // Canonicalize the subject type of the builtin conformance.
+    auto &Ctx = getType()->getASTContext();
+    auto builtinConformance = cast<BuiltinProtocolConformance>(this);
+    SmallVector<Requirement, 4> canonicalRequirements;
+    for (auto &reqt : builtinConformance->getConditionalRequirements()) {
+      canonicalRequirements.push_back(reqt.getCanonical());
+    }
+    return Ctx.getBuiltinConformance(
+      builtinConformance->getType()->getCanonicalType(),
+      builtinConformance->getProtocol(),
+      builtinConformance->getGenericSignature().getCanonicalSignature(),
+      canonicalRequirements,
+      builtinConformance->getBuiltinConformanceKind());
+  }
 
   case ProtocolConformanceKind::Inherited: {
     auto &Ctx = getType()->getASTContext();
diff --git a/lib/SILOptimizer/Mandatory/FlowIsolation.cpp b/lib/SILOptimizer/Mandatory/FlowIsolation.cpp
@@ -422,6 +422,15 @@ void Info::diagnoseAll(AnalysisInfo &info, bool forDeinit,
   if (propertyUses.empty())
     return;
 
+  auto *fn = info.getFunction();
+  auto &ctx = fn->getASTContext();
+
+  // Disable these diagnostics in deinitializers unless complete checking is
+  // enabled.
+  if (forDeinit && ctx.LangOpts.StrictConcurrencyLevel
+        != StrictConcurrency::Complete)
+    return;
+
   // Blame that is valid for the first property use is valid for all uses
   // in this block.
   if (!blame)
@@ -438,7 +447,6 @@ void Info::diagnoseAll(AnalysisInfo &info, bool forDeinit,
     }
   }
 
-  auto *fn = info.getFunction();
   auto &diag = fn->getASTContext().Diags;
 
   SILLocation blameLoc = blame->getDebugLocation().getLocation();
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
@@ -8564,8 +8564,8 @@ static Optional<SolutionApplicationTarget> applySolutionToInitialization(
         wrappedVar, initType->mapTypeOutOfContext());
 
     // Record the semantic initializer on the outermost property wrapper.
-    wrappedVar->getAttachedPropertyWrappers().front()
-        ->setSemanticInit(initializer);
+    wrappedVar->getOutermostAttachedPropertyWrapper()->setSemanticInit(
+        initializer);
 
     // If this is a wrapped parameter, we're done.
     if (isa<ParamDecl>(wrappedVar))
@@ -8983,7 +8983,7 @@ ExprWalker::rewriteTarget(SolutionApplicationTarget target) {
     return target;
   } else if (auto *wrappedVar = target.getAsUninitializedWrappedVar()) {
     // Get the outermost wrapper type from the solution
-    auto outermostWrapper = wrappedVar->getAttachedPropertyWrappers().front();
+    auto outermostWrapper = wrappedVar->getOutermostAttachedPropertyWrapper();
     auto backingType = solution.simplifyType(
         solution.getType(outermostWrapper->getTypeExpr()));
 
diff --git a/lib/Sema/CSClosure.cpp b/lib/Sema/CSClosure.cpp
@@ -85,6 +85,34 @@ class TypeVariableRefFinder : public ASTWalker {
         }
 
         inferVariables(type);
+        return {true, expr};
+      }
+
+      auto var = dyn_cast<VarDecl>(decl);
+      if (!var)
+        return {true, expr};
+
+      if (auto *wrappedVar = var->getOriginalWrappedProperty()) {
+        auto outermostWrapperAttr =
+            wrappedVar->getOutermostAttachedPropertyWrapper();
+
+        // If the attribute doesn't have a type it could only mean
+        // that the declaration was incorrect.
+        if (!CS.hasType(outermostWrapperAttr->getTypeExpr()))
+          return {true, expr};
+
+        auto wrapperType =
+            CS.simplifyType(CS.getType(outermostWrapperAttr->getTypeExpr()));
+
+        if (var->getName().hasDollarPrefix()) {
+          // $<name> is the projected value var
+          CS.setType(var, computeProjectedValueType(wrappedVar, wrapperType));
+        } else {
+          // _<name> is the wrapper var
+          CS.setType(var, computeWrappedValueType(wrappedVar, wrapperType));
+        }
+
+        return {true, expr};
       }
     }
 
diff --git a/lib/Sema/CSDiagnostics.cpp b/lib/Sema/CSDiagnostics.cpp
@@ -3568,7 +3568,7 @@ bool InvalidProjectedValueArgument::diagnoseAsError() {
   if (!param->hasAttachedPropertyWrapper()) {
     param->diagnose(diag::property_wrapper_param_no_wrapper, param->getName());
   } else if (!param->hasImplicitPropertyWrapper() &&
-             param->getAttachedPropertyWrappers().front()->hasArgs()) {
+             param->getOutermostAttachedPropertyWrapper()->hasArgs()) {
     param->diagnose(diag::property_wrapper_param_attr_arg);
   } else {
     Type backingType;
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
@@ -9989,7 +9989,7 @@ bool ConstraintSystem::resolveClosure(TypeVariableType *typeVar,
         wrappedValueType = createTypeVariable(getConstraintLocator(paramDecl),
                                               TVO_CanBindToHole | TVO_CanBindToLValue);
       } else {
-        auto *wrapperAttr = paramDecl->getAttachedPropertyWrappers().front();
+        auto *wrapperAttr = paramDecl->getOutermostAttachedPropertyWrapper();
         auto wrapperType = paramDecl->getAttachedPropertyWrapperType(0);
         backingType = replaceInferableTypesWithTypeVars(
             wrapperType, getConstraintLocator(wrapperAttr->getTypeRepr()));
diff --git a/lib/Sema/ConstraintSystem.cpp b/lib/Sema/ConstraintSystem.cpp
@@ -6327,9 +6327,9 @@ void ConstraintSystem::diagnoseFailureFor(SolutionApplicationTarget target) {
     DE.diagnose(expr->getLoc(), diag::type_of_expression_is_ambiguous)
         .highlight(expr->getSourceRange());
   } else if (auto *wrappedVar = target.getAsUninitializedWrappedVar()) {
-    auto *wrapper = wrappedVar->getAttachedPropertyWrappers().back();
+    auto *outerWrapper = wrappedVar->getOutermostAttachedPropertyWrapper();
     Type propertyType = wrappedVar->getInterfaceType();
-    Type wrapperType = wrapper->getType();
+    Type wrapperType = outerWrapper->getType();
 
     // Emit the property wrapper fallback diagnostic
     wrappedVar->diagnose(diag::property_wrapper_incompatible_property,
diff --git a/test/Concurrency/flow_isolation_nonstrict.swift b/test/Concurrency/flow_isolation_nonstrict.swift
@@ -1,5 +1,6 @@
 // RUN: %target-swift-frontend -strict-concurrency=targeted -swift-version 5 -parse-as-library -emit-sil -verify %s
 
+@_nonSendable
 class NonSendableType {
   var x: Int = 0
   func f() {}
@@ -28,3 +29,14 @@ actor CheckDeinitFromActor {
     ns = nil
   }
 }
+
+@MainActor class X {
+  var ns: NonSendableType = NonSendableType()
+
+  nonisolated func something() { }
+
+  deinit {
+    something()
+    print(ns)
+  }
+}
diff --git a/test/SILGen/opaque_type_sendable_requirement_canonicalization.swift b/test/SILGen/opaque_type_sendable_requirement_canonicalization.swift
@@ -0,0 +1,21 @@
+// RUN: %target-swift-emit-silgen -disable-availability-checking -verify %s
+
+// rdar://94877954
+
+// `dynamic` prevents SILGen from lowering away
+// the opaque return type of `foo`
+dynamic func foo<T: Sendable>(f: () -> T) -> some Sendable {
+    if #available(macOS 11.0, *) {
+        return f()
+    } else {
+        return ()
+    }
+}
+
+func bar() {
+    let x: Void = ()
+    let y: () = ()
+    var a = foo { x }
+    a = foo { y }
+    _ = a
+}
diff --git a/validation-test/Sema/type_checker_crashers_fixed/issue59294.swift b/validation-test/Sema/type_checker_crashers_fixed/issue59294.swift
@@ -1,6 +1,7 @@
 // RUN: %target-typecheck-verify-swift
 
 // https://github.com/apple/swift/issues/59294
+// https://github.com/apple/swift/issues/59295
 
 @propertyWrapper
 struct WrapperValue<Value> {
@@ -25,18 +26,94 @@ struct WrapperValue<Value> {
   func printValue() {
     print(value)
   }
+
+  func returnValue() -> Value {
+    return value
+  }
 }
 
+@propertyWrapper
+struct OuterWrapper<Value> {
+  var value: Value
+  init(wrappedValue: Value) {
+    self.value = wrappedValue
+  }
+
+  var projectedValue: Self {
+    return self
+  }
+
+  var wrappedValue: Value {
+    get {
+      self.value
+    }
+    set {
+      self.value = newValue
+    }
+  }
+}
 
 class Test {
   static func test() {
     return [0, 1, 2].compactMap { _ in // expected-error {{unexpected non-void return value in void function}} expected-note {{did you mean to add a return type?}}
       @WrapperValue var value: Bool? = false
       if value != nil {
+        $value.printValue()
         return false
       }
 
       return value ?? false
     }
   }
+  static func testProjectedAndWrapperVars() {
+    func test(_: (Int) -> Bool) {}
+    func test(_: (String) -> Void) {}
+
+    test {
+      @WrapperValue var value = $0
+      if $value.returnValue() > 0 {
+        test {
+          return $value.returnValue() == $0 &&
+                 _value == $0
+        }
+      }
+      return false
+    }
+
+    test {
+      @WrapperValue var value = $0
+
+      test {
+        if _value != $0 { // Ok
+          $value.printValue()
+        }
+      }
+    }
+  }
+
+  static func testNestedWrappers() {
+    func test(_: (Bool) -> Void) {}
+    func test(_: () -> Void) {}
+
+    test {
+      if true {
+        @OuterWrapper @WrapperValue var value = $0
+        if true {
+          let _: Bool = _value == $0
+          let _: OuterWrapper<WrapperValue<Bool>> = $value
+          let _: Bool = value
+        }
+      }
+    }
+  }
+
+  static func invalidVar() {
+    _ = [0, 1, 2].compactMap {
+      @WrapperValue var value: Bool? = $0
+      // expected-error@-1 {{cannot convert value of type 'Int' to specified type 'Bool?'}}
+      if true {
+        $value.printValue()
+      }
+    }
+  }
 }
