Merge pull request #2402 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

include/swift/AST/DiagnosticsParse.def

@@ -1224,6 +1224,9 @@ NOTE(super_in_closure_with_capture_here,none,
      "'self' explicitly captured here", ())
 
 ERROR(try_before_await,none, "'await' must precede 'try'", ())
+WARNING(warn_await_keyword,none, 
+      "future versions of Swift reserve the word 'await'; "
+      "if this name is unavoidable, use backticks to escape it", ())
 
 // Tuples and parenthesized expressions
 ERROR(expected_expr_in_expr_list,none,

include/swift/IDE/IDERequests.h

@@ -234,7 +234,7 @@ class CollectOverriddenDeclsRequest:
 //----------------------------------------------------------------------------//
 struct ProtocolNameOwner {
   DeclContext *DC;
-  StringRef Name;
+  std::string Name;
   ProtocolNameOwner(DeclContext *DC, StringRef Name): DC(DC), Name(Name) {}
 
   friend llvm::hash_code hash_value(const ProtocolNameOwner &CI) {

include/swift/SIL/InstructionUtils.h

@@ -37,9 +37,13 @@ SILValue stripCasts(SILValue V);
 /// mark_dependence) from the current SILValue.
 SILValue stripCastsWithoutMarkDependence(SILValue V);
 
-/// Return the underlying SILValue after stripping off all copy_value and
+/// Return the underlying SILValue after looking through all copy_value and
 /// begin_borrow instructions.
-SILValue stripOwnershipInsts(SILValue v);
+SILValue lookThroughOwnershipInsts(SILValue v);
+
+/// Return the underlying SILValue after looking through all copy_value
+/// instructions.
+SILValue lookThroughCopyValueInsts(SILValue v);
 
 /// Return the underlying SILValue after stripping off all upcasts from the
 /// current SILValue.

include/swift/SIL/SILInstruction.h

@@ -523,12 +523,20 @@ class SILInstruction
 private:
   /// Predicate used to filter OperandValueRange.
   struct OperandToValue;
+  /// Predicate used to filter TransformedOperandValueRange.
+  struct OperandToTransformedValue;
 
 public:
   using OperandValueRange =
       OptionalTransformRange<ArrayRef<Operand>, OperandToValue>;
+  using TransformedOperandValueRange =
+      OptionalTransformRange<ArrayRef<Operand>, OperandToTransformedValue>;
+
   OperandValueRange
   getOperandValues(bool skipTypeDependentOperands = false) const;
+  TransformedOperandValueRange
+  getOperandValues(std::function<SILValue(SILValue)> transformFn,
+                   bool skipTypeDependentOperands) const;
 
   SILValue getOperand(unsigned Num) const {
     return getAllOperands()[Num].get();
@@ -727,13 +735,40 @@ struct SILInstruction::OperandToValue {
   }
 };
 
+struct SILInstruction::OperandToTransformedValue {
+  const SILInstruction &i;
+  std::function<SILValue(SILValue)> transformFn;
+  bool skipTypeDependentOps;
+
+  OperandToTransformedValue(const SILInstruction &i,
+                            std::function<SILValue(SILValue)> transformFn,
+                            bool skipTypeDependentOps)
+      : i(i), transformFn(transformFn),
+        skipTypeDependentOps(skipTypeDependentOps) {}
+
+  Optional<SILValue> operator()(const Operand &use) const {
+    if (skipTypeDependentOps && i.isTypeDependentOperand(use))
+      return None;
+    return transformFn(use.get());
+  }
+};
+
 inline auto
 SILInstruction::getOperandValues(bool skipTypeDependentOperands) const
     -> OperandValueRange {
   return OperandValueRange(getAllOperands(),
                            OperandToValue(*this, skipTypeDependentOperands));
 }
 
+inline auto
+SILInstruction::getOperandValues(std::function<SILValue(SILValue)> transformFn,
+                                 bool skipTypeDependentOperands) const
+    -> TransformedOperandValueRange {
+  return TransformedOperandValueRange(
+      getAllOperands(),
+      OperandToTransformedValue(*this, transformFn, skipTypeDependentOperands));
+}
+
 struct SILInstruction::OperandToType {
   const SILInstruction &i;
 

include/swift/SILOptimizer/Utils/OwnershipOptUtils.h

@@ -42,7 +42,7 @@ struct OwnershipFixupContext {
   /// Namely, we do not support RAUWing values with ValueOwnershipKind::None
   /// that have uses that do not require ValueOwnershipKind::None or
   /// ValueOwnershipKind::Any.
-  static bool canFixUpOwnershipForRAUW(SingleValueInstruction *oldValue,
+  static bool canFixUpOwnershipForRAUW(const SingleValueInstruction *oldValue,
                                        SILValue newValue);
 };
 

lib/Parse/ParseExpr.cpp

@@ -399,16 +399,22 @@ ParserResult<Expr> Parser::parseExprSequenceElement(Diag<> message,
   SyntaxParsingContext ElementContext(SyntaxContext,
                                       SyntaxContextKind::Expr);
 
-  if (shouldParseExperimentalConcurrency() && Tok.isContextualKeyword("await")) {
-    SourceLoc awaitLoc = consumeToken();
-    ParserResult<Expr> sub =
-      parseExprSequenceElement(diag::expected_expr_after_await, isExprBasic);
-    if (!sub.hasCodeCompletion() && !sub.isNull()) {
-      ElementContext.setCreateSyntax(SyntaxKind::AwaitExpr);
-      sub = makeParserResult(new (Context) AwaitExpr(awaitLoc, sub.get()));
-    }
+  if (Tok.isContextualKeyword("await")) {
+    if (shouldParseExperimentalConcurrency()) {
+      SourceLoc awaitLoc = consumeToken();
+      ParserResult<Expr> sub =
+        parseExprSequenceElement(diag::expected_expr_after_await, isExprBasic);
+      if (!sub.hasCodeCompletion() && !sub.isNull()) {
+        ElementContext.setCreateSyntax(SyntaxKind::AwaitExpr);
+        sub = makeParserResult(new (Context) AwaitExpr(awaitLoc, sub.get()));
+      }
 
-    return sub;
+      return sub;
+    } else {
+      // warn that future versions of Swift will parse this token differently.
+      diagnose(Tok.getLoc(), diag::warn_await_keyword)
+        .fixItReplace(Tok.getLoc(), "`await`");
+    }
   }
 
   SourceLoc tryLoc;

lib/SIL/IR/SILInstruction.cpp

@@ -372,6 +372,14 @@ namespace {
       return true;
     }
 
+    bool visitDestructureStructInst(const DestructureStructInst *RHS) {
+      return true;
+    }
+
+    bool visitDestructureTupleInst(const DestructureTupleInst *RHS) {
+      return true;
+    }
+
     bool visitAllocRefInst(const AllocRefInst *RHS) {
       auto *LHSInst = cast<AllocRefInst>(LHS);
       auto LHSTypes = LHSInst->getTailAllocatedTypes();

lib/SIL/Utils/InstructionUtils.cpp

@@ -25,7 +25,7 @@
 
 using namespace swift;
 
-SILValue swift::stripOwnershipInsts(SILValue v) {
+SILValue swift::lookThroughOwnershipInsts(SILValue v) {
   while (true) {
     switch (v->getKind()) {
     default:
@@ -37,6 +37,14 @@ SILValue swift::stripOwnershipInsts(SILValue v) {
   }
 }
 
+SILValue swift::lookThroughCopyValueInsts(SILValue val) {
+  while (auto *cvi =
+             dyn_cast_or_null<CopyValueInst>(val->getDefiningInstruction())) {
+    val = cvi->getOperand();
+  }
+  return val;
+}
+
 /// Strip off casts/indexing insts/address projections from V until there is
 /// nothing left to strip.
 ///
@@ -46,7 +54,7 @@ SILValue swift::getUnderlyingObject(SILValue v) {
     SILValue v2 = stripCasts(v);
     v2 = stripAddressProjections(v2);
     v2 = stripIndexingInsts(v2);
-    v2 = stripOwnershipInsts(v2);
+    v2 = lookThroughOwnershipInsts(v2);
     if (v2 == v)
       return v2;
     v = v2;
@@ -58,7 +66,7 @@ SILValue swift::getUnderlyingObjectStopAtMarkDependence(SILValue v) {
     SILValue v2 = stripCastsWithoutMarkDependence(v);
     v2 = stripAddressProjections(v2);
     v2 = stripIndexingInsts(v2);
-    v2 = stripOwnershipInsts(v2);
+    v2 = lookThroughOwnershipInsts(v2);
     if (v2 == v)
       return v2;
     v = v2;
@@ -137,7 +145,7 @@ SILValue swift::stripCasts(SILValue v) {
         continue;
       }
     }
-    SILValue v2 = stripOwnershipInsts(v);
+    SILValue v2 = lookThroughOwnershipInsts(v);
     if (v2 != v) {
       v = v2;
       continue;
@@ -159,7 +167,7 @@ SILValue swift::stripUpCasts(SILValue v) {
     }
 
     SILValue v2 = stripSinglePredecessorArgs(v);
-    v2 = stripOwnershipInsts(v2);
+    v2 = lookThroughOwnershipInsts(v2);
     if (v2 == v) {
       return v2;
     }
@@ -179,7 +187,7 @@ SILValue swift::stripClassCasts(SILValue v) {
       continue;
     }
 
-    SILValue v2 = stripOwnershipInsts(v);
+    SILValue v2 = lookThroughOwnershipInsts(v);
     if (v2 != v) {
       v = v2;
       continue;