Merge pull request #3477 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

lib/APIDigester/ModuleAnalyzerNodes.cpp

@@ -2165,7 +2165,9 @@ static parseJsonEmit(SDKContext &Ctx, StringRef FileName) {
 
   // Load the input file.
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> FileBufOrErr =
-    vfs::getFileOrSTDIN(*Ctx.getSourceMgr().getFileSystem(), FileName);
+    vfs::getFileOrSTDIN(*Ctx.getSourceMgr().getFileSystem(), FileName,
+                        /*FileSize*/-1, /*RequiresNullTerminator*/true,
+                        /*IsVolatile*/false, /*RetryCount*/30);
   if (!FileBufOrErr) {
     llvm_unreachable("Failed to read JSON file");
   }

lib/IDE/Refactoring.cpp

@@ -6137,26 +6137,30 @@ class AsyncConverter : private SourceEntityWalker {
     return OutputStr;
   }
 
+  /// Retrieves the SourceRange of the preceding comment, or an invalid range if
+  /// there is no preceding comment.
+  CharSourceRange getPrecedingCommentRange(SourceLoc Loc) {
+    auto Tokens = SF->getAllTokens();
+    auto TokenIter = token_lower_bound(Tokens, Loc);
+    if (TokenIter == Tokens.end() || !TokenIter->hasComment())
+      return CharSourceRange();
+    return TokenIter->getCommentRange();
+  }
+
   /// Retrieves the location for the start of a comment attached to the token
   /// at the provided location, or the location itself if there is no comment.
   SourceLoc getLocIncludingPrecedingComment(SourceLoc Loc) {
-    auto Tokens = SF->getAllTokens();
-    auto TokenIter = token_lower_bound(Tokens, Loc);
-    if (TokenIter != Tokens.end() && TokenIter->hasComment())
-      return TokenIter->getCommentStart();
-    return Loc;
+    auto CommentRange = getPrecedingCommentRange(Loc);
+    if (CommentRange.isInvalid())
+      return Loc;
+    return CommentRange.getStart();
   }
 
-  /// If the provided SourceLoc has a preceding comment, print it out. Returns
-  /// true if a comment was printed, false otherwise.
-  bool printCommentIfNeeded(SourceLoc Loc, bool AddNewline = false) {
-    auto PrecedingLoc = getLocIncludingPrecedingComment(Loc);
-    if (Loc == PrecedingLoc)
-      return false;
-    if (AddNewline)
-      OS << "\n";
-    OS << CharSourceRange(SM, PrecedingLoc, Loc).str();
-    return true;
+  /// If the provided SourceLoc has a preceding comment, print it out.
+  void printCommentIfNeeded(SourceLoc Loc) {
+    auto CommentRange = getPrecedingCommentRange(Loc);
+    if (CommentRange.isValid())
+      OS << "\n" << CommentRange.str();
   }
 
   void convertNodes(const NodesToPrint &ToPrint) {
@@ -6171,8 +6175,6 @@ class AsyncConverter : private SourceEntityWalker {
 
     // First print the nodes we've been asked to print.
     for (auto Node : ToPrint.getNodes()) {
-      OS << "\n";
-
       // If we need to print comments, do so now.
       while (!CommentLocs.empty()) {
         auto CommentLoc = CommentLocs.back().getOpaquePointerValue();
@@ -6187,16 +6189,13 @@ class AsyncConverter : private SourceEntityWalker {
 
         printCommentIfNeeded(CommentLocs.pop_back_val());
       }
+      OS << "\n";
       convertNode(Node);
     }
 
     // We're done printing nodes. Make sure to output the remaining comments.
-    bool HasPrintedComment = false;
-    while (!CommentLocs.empty()) {
-      HasPrintedComment |=
-          printCommentIfNeeded(CommentLocs.pop_back_val(),
-                               /*AddNewline*/ !HasPrintedComment);
-    }
+    while (!CommentLocs.empty())
+      printCommentIfNeeded(CommentLocs.pop_back_val());
   }
 
   void convertNode(ASTNode Node, SourceLoc StartOverride = {},

lib/Sema/CSGen.cpp

@@ -2191,38 +2191,54 @@ namespace {
           }
         }
 
-        if (!varType)
+        if (!varType) {
           varType = CS.createTypeVariable(CS.getConstraintLocator(locator),
                                           TVO_CanBindToNoEscape);
 
+          // If this is either a `weak` declaration or capture e.g.
+          // `weak var ...` or `[weak self]`. Let's wrap type variable
+          // into an optional.
+          if (optionality == ReferenceOwnershipOptionality::Required)
+            varType = TypeChecker::getOptionalType(var->getLoc(), varType);
+        }
+
         // When we are supposed to bind pattern variables, create a fresh
         // type variable and a one-way constraint to assign it to either the
         // deduced type or the externally-imposed type.
         Type oneWayVarType;
         if (bindPatternVarsOneWay) {
           oneWayVarType = CS.createTypeVariable(
               CS.getConstraintLocator(locator), TVO_CanBindToNoEscape);
-          CS.addConstraint(
-              ConstraintKind::OneWayEqual, oneWayVarType,
-              externalPatternType ? externalPatternType : varType, locator);
-        }
-
-        // If there is an externally-imposed type.
 
-        switch (optionality) {
-        case ReferenceOwnershipOptionality::Required:
-          varType = TypeChecker::getOptionalType(var->getLoc(), varType);
-          assert(!varType->hasError());
+          // If there is an externally-imposed pattern type and the
+          // binding/capture is marked as `weak`, let's make sure
+          // that the imposed type is optional.
+          //
+          // Note that there is no need to check `varType` since
+          // it's only "externally" bound if this pattern isn't marked
+          // as `weak`.
+          if (externalPatternType &&
+              optionality == ReferenceOwnershipOptionality::Required) {
+            // If the type is not yet known, let's add a constraint
+            // to make sure that it can only be bound to an optional type.
+            if (externalPatternType->isTypeVariableOrMember()) {
+              auto objectTy = CS.createTypeVariable(
+                  CS.getConstraintLocator(locator.withPathElement(
+                      ConstraintLocator::OptionalPayload)),
+                  TVO_CanBindToLValue | TVO_CanBindToNoEscape);
 
-          if (oneWayVarType) {
-            oneWayVarType =
-                TypeChecker::getOptionalType(var->getLoc(), oneWayVarType);
+              CS.addConstraint(ConstraintKind::OptionalObject,
+                               externalPatternType, objectTy, locator);
+            } else if (!externalPatternType->getOptionalObjectType()) {
+              // TODO(diagnostics): A tailored fix to indiciate that `weak`
+              // should have an optional type.
+              return Type();
+            }
           }
-          break;
 
-        case ReferenceOwnershipOptionality::Allowed:
-        case ReferenceOwnershipOptionality::Disallowed:
-          break;
+          CS.addConstraint(ConstraintKind::OneWayEqual, oneWayVarType,
+                           externalPatternType ? externalPatternType : varType,
+                           locator);
         }
 
         // If we have a type to ascribe to the variable, do so now.

test/Constraints/result_builder.swift

@@ -788,3 +788,19 @@ let ts1 = MyTupleStruct {
 
 // CHECK: MyTupleStruct<(Int, String, Optional<String>), (Double, String)>(first: (Function), second: (3.14159, "blah"))
 print(ts1)
+
+// Make sure that `weakV` is `Test?` and not `Test??`
+func test_weak_optionality_stays_the_same() {
+  class Test {
+    func fn() -> Int { 42 }
+  }
+
+  tuplify(true) { c in
+    weak var weakV: Test? = Test()
+
+    0
+    if let v = weakV {
+      v.fn()
+    }
+  }
+}

test/refactoring/ConvertAsync/basic.swift

@@ -835,7 +835,6 @@ func testPreserveComments2() {
 // PRESERVE-COMMENTS-ERROR-NEXT:   // f
 // PRESERVE-COMMENTS-ERROR-NEXT:   print("fun")
 // PRESERVE-COMMENTS-ERROR-NEXT:   // g
-// PRESERVE-COMMENTS-ERROR-NEXT:  {{ }}
 // PRESERVE-COMMENTS-ERROR-NEXT: }
 
 // RUN: %refactor -convert-to-async -dump-text -source-filename %s -pos=%(line+1):1 | %FileCheck -check-prefix=PRESERVE-TRAILING-COMMENT-FN %s

test/refactoring/ConvertAsync/convert_function.swift

@@ -226,7 +226,6 @@ func callNonAsyncInAsyncComment(_ completion: @escaping (String) -> Void) {
 // CALL-NON-ASYNC-IN-ASYNC-COMMENT-NEXT:       // i
 // CALL-NON-ASYNC-IN-ASYNC-COMMENT-NEXT:     }
 // CALL-NON-ASYNC-IN-ASYNC-COMMENT-NEXT:     // j
-// CALL-NON-ASYNC-IN-ASYNC-COMMENT-NEXT:     {{ }}
 // CALL-NON-ASYNC-IN-ASYNC-COMMENT-NEXT:     // k
 // CALL-NON-ASYNC-IN-ASYNC-COMMENT-NEXT:   }
 // CALL-NON-ASYNC-IN-ASYNC-COMMENT-NEXT: }

test/refactoring/ConvertAsync/convert_params_single.swift

@@ -87,14 +87,12 @@ func testParamsSingle() async throws {
   // BOUND-COMMENT-NEXT: // l
   // BOUND-COMMENT-NEXT: print("after")
   // BOUND-COMMENT-NEXT: // m
-  // BOUND-COMMENT-NEXT: {{ }}
   // BOUND-COMMENT-NEXT: } catch let bad {
   // BOUND-COMMENT-NEXT: // d
   // BOUND-COMMENT-NEXT: // e
   // BOUND-COMMENT-NEXT: print("got error \(bad)")
   // BOUND-COMMENT-NEXT: // f
   // BOUND-COMMENT-NEXT: // g
-  // BOUND-COMMENT-NEXT: {{ }}
   // BOUND-COMMENT-NEXT: }
 
 

test/refactoring/ConvertAsync/convert_result.swift

@@ -381,7 +381,6 @@ func testResultConversion() async throws {
   // NESTEDBREAK-COMMENT-NEXT: // l
   // NESTEDBREAK-COMMENT-NEXT: print("after")
   // NESTEDBREAK-COMMENT-NEXT: // m
-  // NESTEDBREAK-COMMENT-NEXT: {{ }}
   // NESTEDBREAK-COMMENT-NOT: }
 
   // RUN: %refactor-check-compiles -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+1):3 | %FileCheck -check-prefix=ERROR-BLOCK-COMMENT %s
@@ -416,13 +415,11 @@ func testResultConversion() async throws {
   // ERROR-BLOCK-COMMENT-NEXT:   // h
   // ERROR-BLOCK-COMMENT-NEXT:   print("after")
   // ERROR-BLOCK-COMMENT-NEXT:   // i
-  // ERROR-BLOCK-COMMENT-NEXT:   {{ }}
   // ERROR-BLOCK-COMMENT-NEXT: } catch {
   // ERROR-BLOCK-COMMENT-NEXT:   // e
   // ERROR-BLOCK-COMMENT-NEXT:   print("fail")
   // ERROR-BLOCK-COMMENT-NEXT:   // f
   // ERROR-BLOCK-COMMENT-NEXT:   // g
-  // ERROR-BLOCK-COMMENT-NEXT:   {{ }}
   // ERROR-BLOCK-COMMENT-NEXT: }
   // ERROR-BLOCK-COMMENT-NOT: }