Merge branch 'release/5.3' of github.com:swiftwasm/swift into maxd/5.3-merge

# Conflicts:
#	test/stdlib/simd.swift.gyb

Author: MaxDesiatov

README.md

@@ -91,7 +91,7 @@ Please make sure you use Python 2.x. Python 3.x is not supported currently.
 
 #### macOS
 
-To build for macOS, you need [Xcode 11.4](https://developer.apple.com/xcode/resources/).
+To build for macOS, you need [Xcode 12 beta](https://developer.apple.com/xcode/resources/).
 The required version of Xcode changes frequently, and is often a beta release.
 Check this document or the host information on <https://ci.swift.org> for the
 current required version.

benchmark/cmake/modules/AddSwiftBenchmarkSuite.cmake

@@ -660,8 +660,11 @@ function (swift_benchmark_compile_archopts)
           "-m${triple_platform}-version-min=${ver}"
           "-lobjc"
           "-L${SWIFT_LIBRARY_PATH}/${BENCH_COMPILE_ARCHOPTS_PLATFORM}"
+          "-L${sdk}/usr/lib/swift"
           "-Xlinker" "-rpath"
           "-Xlinker" "${SWIFT_LINK_RPATH}"
+          "-Xlinker" "-rpath"
+          "-Xlinker" "/usr/lib/swift"
           ${bench_library_objects}
           ${bench_driver_objects}
           ${ld64_add_ast_path_opts}

include/swift/IDE/ConformingMethodList.h

@@ -42,6 +42,7 @@ class ConformingMethodListConsumer {
 public:
   virtual ~ConformingMethodListConsumer() {}
   virtual void handleResult(const ConformingMethodListResult &result) = 0;
+  virtual void setReusingASTContext(bool flag) = 0;
 };
 
 /// Printing consumer
@@ -53,6 +54,7 @@ class PrintingConformingMethodListConsumer
   PrintingConformingMethodListConsumer(llvm::raw_ostream &OS) : OS(OS) {}
 
   void handleResult(const ConformingMethodListResult &result) override;
+  void setReusingASTContext(bool flag) override {}
 };
 
 /// Create a factory for code completion callbacks.

include/swift/IDE/TypeContextInfo.h

@@ -38,6 +38,7 @@ class TypeContextInfoConsumer {
 public:
   virtual ~TypeContextInfoConsumer() {}
   virtual void handleResults(ArrayRef<TypeContextInfoItem>) = 0;
+  virtual void setReusingASTContext(bool flag) = 0;
 };
 
 /// Printing consumer
@@ -48,6 +49,7 @@ class PrintingTypeContextInfoConsumer : public TypeContextInfoConsumer {
   PrintingTypeContextInfoConsumer(llvm::raw_ostream &OS) : OS(OS) {}
 
   void handleResults(ArrayRef<TypeContextInfoItem>) override;
+  void setReusingASTContext(bool flag) override {}
 };
 
 /// Create a factory for code completion callbacks.

lib/AST/Attr.cpp

@@ -749,8 +749,11 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
     if (auto *VD = dyn_cast<ValueDecl>(D)) {
       if (auto *BD = VD->getOverriddenDecl()) {
         if (!BD->hasClangNode() &&
-            VD->isEffectiveLinkageMoreVisibleThan(BD))
+            !BD->getFormalAccessScope(VD->getDeclContext(),
+                                      /*treatUsableFromInlineAsPublic*/ true)
+                 .isPublic()) {
           return false;
+        }
       }
     }
     break;

lib/Demangling/Demangler.cpp

@@ -2007,6 +2007,8 @@ NodePointer Demangler::demangleArchetype() {
     if (!demangleBoundGenerics(boundGenericArgs, retroactiveConformances))
       return nullptr;
     auto Name = popNode();
+    if (!Name)
+      return nullptr;
     auto opaque = createWithChildren(Node::Kind::OpaqueType, Name,
                                    createNode(Node::Kind::Index, index));
     auto boundGenerics = createNode(Node::Kind::TypeList);

lib/IDE/CodeCompletion.cpp

@@ -6158,15 +6158,29 @@ void CodeCompletionCallbacksImpl::doneParsing() {
       if (IsAtStartOfLine) {
         //   foo() {}
         //   <HERE>
-        // Global completion.
+
         auto &Sink = CompletionContext.getResultSink();
-        addDeclKeywords(Sink);
-        addStmtKeywords(Sink, MaybeFuncBody);
-        addSuperKeyword(Sink);
-        addLetVarKeywords(Sink);
-        addExprKeywords(Sink);
-        addAnyTypeKeyword(Sink, CurDeclContext->getASTContext().TheAnyType);
-        DoPostfixExprBeginning();
+        if (isa<Initializer>(CurDeclContext))
+          CurDeclContext = CurDeclContext->getParent();
+
+        if (CurDeclContext->isTypeContext()) {
+          // Override completion (CompletionKind::NominalMemberBeginning).
+          addDeclKeywords(Sink);
+          addLetVarKeywords(Sink);
+          SmallVector<StringRef, 0> ParsedKeywords;
+          CompletionOverrideLookup OverrideLookup(Sink, Context, CurDeclContext,
+                                                  ParsedKeywords, SourceLoc());
+          OverrideLookup.getOverrideCompletions(SourceLoc());
+        } else {
+          // Global completion (CompletionKind::PostfixExprBeginning).
+          addDeclKeywords(Sink);
+          addStmtKeywords(Sink, MaybeFuncBody);
+          addSuperKeyword(Sink);
+          addLetVarKeywords(Sink);
+          addExprKeywords(Sink);
+          addAnyTypeKeyword(Sink, Context.TheAnyType);
+          DoPostfixExprBeginning();
+        }
       } else {
         //   foo() {} <HERE>
         // Member completion.

lib/IDE/Formatting.cpp

@@ -1906,6 +1906,11 @@ class FormatWalker : public ASTWalker {
       return Aligner.getContextAndSetAlignment(CtxOverride);
     }
 
+    // There are no parens at this point, so if there are no parameters either,
+    // this shouldn't be a context (it's an implicit parameter list).
+    if (!PL->size())
+      return None;
+
     ListAligner Aligner(SM, TargetLocation, ContextLoc, Range.Start);
     for (auto *PD: *PL)
       Aligner.updateAlignment(PD->getSourceRange(), PD);
@@ -2336,8 +2341,17 @@ class FormatWalker : public ASTWalker {
         return None;
 
       ListAligner Aligner(SM, TargetLocation, L, L, R, true);
-      for (auto *Elem: AE->getElements())
-        Aligner.updateAlignment(Elem->getStartLoc(), Elem->getEndLoc(), Elem);
+      for (auto *Elem: AE->getElements()) {
+        SourceRange ElemRange = Elem->getSourceRange();
+        Aligner.updateAlignment(ElemRange, Elem);
+        if (isTargetContext(ElemRange)) {
+          Aligner.setAlignmentIfNeeded(CtxOverride);
+          return IndentContext {
+            ElemRange.Start,
+            !OutdentChecker::hasOutdent(SM, ElemRange, Elem)
+          };
+        }
+      }
       return Aligner.getContextAndSetAlignment(CtxOverride);
     }
 

lib/Parse/ParseExpr.cpp

@@ -3228,7 +3228,7 @@ Parser::parseTrailingClosures(bool isExprBasic, SourceRange calleeRange,
       if (CodeCompletion)
         CodeCompletion->completeLabeledTrailingClosure(CCExpr, Tok.isAtStartOfLine());
       consumeToken(tok::code_complete);
-      result.hasCodeCompletion();
+      result.setHasCodeCompletion();
       closures.push_back({Identifier(), SourceLoc(), CCExpr});
       continue;
     }

lib/SILOptimizer/Transforms/CopyForwarding.cpp

@@ -322,6 +322,9 @@ namespace {
 /// This returns false and sets Oper to a valid operand if the instruction is a
 /// projection of the value at the given address. The assumption is that we
 /// cannot deinitialize memory via projections.
+///
+/// This returns true with Oper == nullptr for trivial stores (without a proper
+/// deinit).
 class AnalyzeForwardUse
     : public SILInstructionVisitor<AnalyzeForwardUse, bool> {
 public:
@@ -352,7 +355,10 @@ class AnalyzeForwardUse
     return true;
   }
   bool visitStoreInst(StoreInst *Store) {
-    llvm_unreachable("illegal reinitialization or store of an address");
+    // Trivial values may be stored prior to the next deinit. A store is an
+    // implicit "deinit" with no operand to replace.
+    assert(Store->getOperand(0)->getType().isTrivial(*Store->getFunction()));
+    return true;
   }
   bool visitDestroyAddrInst(DestroyAddrInst *UserInst) {
     Oper = &UserInst->getOperandRef();
@@ -1011,15 +1017,17 @@ bool CopyForwarding::forwardPropagateCopy() {
       continue;
 
     AnalyzeForwardUse AnalyzeUse(CopyDest);
-    bool seenDeinit = AnalyzeUse.visit(UserInst);
-    // If this use cannot be analyzed, then abort.
+    bool seenDeinitOrStore = AnalyzeUse.visit(UserInst);
+    if (AnalyzeUse.Oper)
+      ValueUses.push_back(AnalyzeUse.Oper);
+
+    // If this is a deinit or store, we're done searching.
+    if (seenDeinitOrStore)
+      break;
+
+    // If this non-deinit instruction wasn't fully analyzed, bail-out.
     if (!AnalyzeUse.Oper)
       return false;
-    // Otherwise record the operand.
-    ValueUses.push_back(AnalyzeUse.Oper);
-    // If this is a deinit, we're done searching.
-    if (seenDeinit)
-      break;
   }
   if (SI == SE)
     return false;