Merge pull request #3107 from swiftwasm/release/5.4

yonihemi · web-flow · commit eb1052cf8bd0 · 2021-06-17T10:56:51.000+08:00
[pull] swiftwasm-release/5.4 from release/5.4
diff --git a/include/swift/AST/DiagnosticsClangImporter.def b/include/swift/AST/DiagnosticsClangImporter.def
@@ -80,5 +80,7 @@ WARNING(implicit_bridging_header_imported_from_module,none,
         "is deprecated and will be removed in a later version of Swift",
         (StringRef, Identifier))
 
+ERROR(module_map_not_found, none, "module map file '%0' not found", (StringRef))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"
diff --git a/lib/ClangImporter/ClangImporter.cpp b/lib/ClangImporter/ClangImporter.cpp
@@ -1030,8 +1030,38 @@ ClangImporter::createClangInvocation(ClangImporter *importer,
                                                  &tempDiagClient,
                                                  /*owned*/false);
 
-  return clang::createInvocationFromCommandLine(invocationArgs, tempClangDiags,
-                                                nullptr, false, CC1Args);
+  auto CI = clang::createInvocationFromCommandLine(
+      invocationArgs, tempClangDiags, nullptr, false, CC1Args);
+
+  if (!CI) {
+    return CI;
+  }
+
+  // FIXME: clang fails to generate a module if there is a `-fmodule-map-file`
+  // argument pointing to a missing file.
+  // Such missing module files occur frequently in SourceKit. If the files are
+  // missing, SourceKit fails to build SwiftShims (which wouldn't have required
+  // the missing module file), thus fails to load the stdlib and hence looses
+  // all semantic functionality.
+  // To work around this issue, drop all `-fmodule-map-file` arguments pointing
+  // to missing files and report the error that clang would throw manually.
+  // rdar://77516546 is tracking that the clang importer should be more
+  // resilient and provide a module even if there were building it.
+  auto VFS = clang::createVFSFromCompilerInvocation(
+      *CI, *tempClangDiags,
+      importer->Impl.SwiftContext.SourceMgr.getFileSystem());
+  std::vector<std::string> FilteredModuleMapFiles;
+  for (auto ModuleMapFile : CI->getFrontendOpts().ModuleMapFiles) {
+    if (VFS->exists(ModuleMapFile)) {
+      FilteredModuleMapFiles.push_back(ModuleMapFile);
+    } else {
+      importer->Impl.SwiftContext.Diags.diagnose(
+          SourceLoc(), diag::module_map_not_found, ModuleMapFile);
+    }
+  }
+  CI->getFrontendOpts().ModuleMapFiles = FilteredModuleMapFiles;
+
+  return CI;
 }
 
 std::unique_ptr<ClangImporter>
diff --git a/lib/IRGen/IRGenModule.cpp b/lib/IRGen/IRGenModule.cpp
@@ -1632,7 +1632,8 @@ bool IRGenModule::useDllStorage() { return ::useDllStorage(Triple); }
 
 bool IRGenModule::shouldPrespecializeGenericMetadata() {
   auto canPrespecializeTarget =
-      (Triple.isOSDarwin() || Triple.isTvOS() || Triple.isOSLinux());
+      (Triple.isOSDarwin() || Triple.isTvOS() ||
+       (Triple.isOSLinux() && !(Triple.isARM() && Triple.isArch32Bit())));
   if (canPrespecializeTarget && isStandardLibrary()) {
     return true;
   }
diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
@@ -6622,8 +6622,10 @@ BraceStmt *Parser::parseAbstractFunctionBodyImpl(AbstractFunctionDecl *AFD) {
     return nullptr;
 
   BraceStmt *BS = Body.get();
+  // Reset the single expression body status.
+  AFD->setHasSingleExpressionBody(false);
   AFD->setBodyParsed(BS);
-  
+
   if (Parser::shouldReturnSingleExpressionElement(BS->getElements())) {
     auto Element = BS->getLastElement();
     if (auto *stmt = Element.dyn_cast<Stmt *>()) {
diff --git a/lib/SIL/Verifier/SILVerifier.cpp b/lib/SIL/Verifier/SILVerifier.cpp
@@ -1213,21 +1213,6 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
           DebugVars[ArgNo] = VarInfo->Name;
       }
     }
-
-    // Regular locations are allowed on all instructions.
-    if (LocKind == SILLocation::RegularKind)
-      return;
-
-    if (LocKind == SILLocation::ReturnKind ||
-        LocKind == SILLocation::ImplicitReturnKind)
-      require(InstKind == SILInstructionKind::BranchInst ||
-              InstKind == SILInstructionKind::ReturnInst ||
-              InstKind == SILInstructionKind::UnreachableInst,
-        "return locations are only allowed on branch and return instructions");
-
-    if (LocKind == SILLocation::ArtificialUnreachableKind)
-      require(InstKind == SILInstructionKind::UnreachableInst,
-        "artificial locations are only allowed on Unreachable instructions");
   }
 
   /// Check that the types of this value producer are all legal in the function
diff --git a/lib/SILOptimizer/Mandatory/DIMemoryUseCollector.cpp b/lib/SILOptimizer/Mandatory/DIMemoryUseCollector.cpp
@@ -93,13 +93,8 @@ static unsigned getElementCountRec(TypeExpansionContext context,
 }
 
 static std::pair<SILType, bool>
-computeMemorySILType(MarkUninitializedInst *MemoryInst) {
+computeMemorySILType(MarkUninitializedInst *MUI, SILValue Address) {
   // Compute the type of the memory object.
-  auto *MUI = MemoryInst;
-  SILValue Address = MUI;
-  if (auto *PBI = Address->getSingleUserOfType<ProjectBoxInst>()) {
-    Address = PBI;
-  }
   SILType MemorySILType = Address->getType().getObjectType();
 
   // If this is a let variable we're initializing, remember this so we don't
@@ -118,7 +113,13 @@ DIMemoryObjectInfo::DIMemoryObjectInfo(MarkUninitializedInst *MI)
     : MemoryInst(MI) {
   auto &Module = MI->getModule();
 
-  std::tie(MemorySILType, IsLet) = computeMemorySILType(MemoryInst);
+  SILValue Address = MemoryInst;
+  if (auto PBI = MemoryInst->getSingleUserOfType<ProjectBoxInst>()) {
+    IsBox = true;
+    Address = PBI;
+  }
+
+  std::tie(MemorySILType, IsLet) = computeMemorySILType(MI, Address);
 
   // Compute the number of elements to track in this memory object.
   // If this is a 'self' in a delegating initializer, we only track one bit:
diff --git a/lib/SILOptimizer/Mandatory/DIMemoryUseCollector.h b/lib/SILOptimizer/Mandatory/DIMemoryUseCollector.h
@@ -72,6 +72,9 @@ class DIMemoryObjectInfo {
   /// non-empty.
   bool HasDummyElement = false;
 
+  /// True if this object has a single user of type ProjectBoxInst.
+  bool IsBox = false;
+
 public:
   DIMemoryObjectInfo(MarkUninitializedInst *MemoryInst);
 
@@ -98,10 +101,11 @@ class DIMemoryObjectInfo {
   /// instruction. For alloc_box though it returns the project_box associated
   /// with the memory info.
   SingleValueInstruction *getUninitializedValue() const {
-    if (auto *mui = dyn_cast<MarkUninitializedInst>(MemoryInst)) {
-      if (auto *pbi = mui->getSingleUserOfType<ProjectBoxInst>()) {
-        return pbi;
-      }
+    if (IsBox) {
+      // TODO: consider just storing the ProjectBoxInst in this case.
+      auto *pbi = MemoryInst->getSingleUserOfType<ProjectBoxInst>();
+      assert(pbi);
+      return pbi;
     }
     return MemoryInst;
   }
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
@@ -6197,8 +6197,26 @@ void ModuleFile::finishNormalConformance(NormalProtocolConformance *conformance,
     // FIXME: We don't actually want to allocate an archetype here; we just
     // want to get an access path within the protocol.
     auto first = cast<AssociatedTypeDecl>(getDecl(*rawIDIter++));
-    auto second = getType(*rawIDIter++);
-    auto third = cast_or_null<TypeDecl>(getDecl(*rawIDIter++));
+    auto secondOrError = getTypeChecked(*rawIDIter++);
+    Type second;
+    if (secondOrError) {
+      second = *secondOrError;
+    } else if (getContext().LangOpts.EnableDeserializationRecovery) {
+      second = ErrorType::get(getContext());
+      consumeError(secondOrError.takeError());
+    } else {
+      fatal(secondOrError.takeError());
+    }
+    auto thirdOrError = getDeclChecked(*rawIDIter++);
+    TypeDecl *third;
+    if (thirdOrError) {
+      third = cast_or_null<TypeDecl>(*thirdOrError);
+    } else if (getContext().LangOpts.EnableDeserializationRecovery) {
+      third = nullptr;
+      consumeError(thirdOrError.takeError());
+    } else {
+      fatal(thirdOrError.takeError());
+    }
     if (third &&
         isa<TypeAliasDecl>(third) &&
         third->getModuleContext() != getAssociatedModule() &&
diff --git a/stdlib/public/SwiftShims/LibcShims.h b/stdlib/public/SwiftShims/LibcShims.h
@@ -70,7 +70,11 @@ static inline __swift_size_t _swift_stdlib_strlen_unsigned(const unsigned char *
 SWIFT_READONLY
 static inline int _swift_stdlib_memcmp(const void *s1, const void *s2,
                                        __swift_size_t n) {
+#if defined(__APPLE__)
+  extern int memcmp(const void * _Nullable, const void * _Nullable, __swift_size_t);
+#else
   extern int memcmp(const void *, const void *, __swift_size_t);
+#endif
   return memcmp(s1, s2, n);
 }
 
diff --git a/test/Runtime/protocol_conformance_collision.swift b/test/Runtime/protocol_conformance_collision.swift
@@ -46,7 +46,10 @@ func firstHashValue(_ x: P) -> Int {
 }
 
 let osHasWorkaround: Bool
-if #available(macOS 11.3, iOS 14.5, tvOS 14.5, watchOS 7.4, *) {
+// These are deliberately not the standard 9999, as we don't want to hit the
+// special case where it's always available, and we don't want this check to be
+// rewritten in any find/replace operations.
+if #available(macOS 9998, iOS 9998, tvOS 9998, watchOS 9998, *) {
   osHasWorkaround = true
 } else {
   osHasWorkaround = false
diff --git a/test/Serialization/Recovery/Inputs/protocol-requirement-in-implementation-only/module.modulemap b/test/Serialization/Recovery/Inputs/protocol-requirement-in-implementation-only/module.modulemap
@@ -0,0 +1 @@
+module public_lib [system] {}
diff --git a/test/Serialization/Recovery/protocol-requirement-in-implementation-only.swift b/test/Serialization/Recovery/protocol-requirement-in-implementation-only.swift
@@ -0,0 +1,29 @@
+// RUN: %empty-directory(%t)
+
+//// Build the private module and the public module normally.
+//// Force the public module to be system with an underlying Clang module.
+// RUN: %target-swift-frontend -emit-module -DPRIVATE_LIB %s -module-name private_lib -emit-module-path %t/private_lib.swiftmodule
+// RUN: %target-swift-frontend -emit-module -DPUBLIC_LIB %s -module-name public_lib -emit-module-path %t/public_lib.swiftmodule -I %t -I %S/Inputs/protocol-requirement-in-implementation-only -import-underlying-module
+
+//// Printing the public module should not crash when reading the HiddenStruct typealias in `M`.
+// RUN: %target-swift-ide-test -print-module -module-to-print=public_lib -source-filename=x -skip-overrides -I %t
+
+#if PRIVATE_LIB
+
+public struct HiddenStruct {
+  public init() {}
+}
+
+#elseif PUBLIC_LIB
+
+@_implementationOnly import private_lib
+
+protocol SomeProtocol {
+  associatedtype Value
+  static var defaultValue: Value { get }
+}
+public struct M: SomeProtocol {
+  typealias Value = HiddenStruct
+  static let defaultValue = HiddenStruct()
+}
+#endif
diff --git a/test/SourceKit/CodeComplete/complete_sequence_rdar75358153.swift b/test/SourceKit/CodeComplete/complete_sequence_rdar75358153.swift
@@ -0,0 +1,47 @@
+// BEGIN t1.swift
+enum E {
+  case foo, bar
+}
+func foo(_ arg: E) {}
+func test(val: E) {
+  foo(.bar)
+}
+
+// BEGIN t2.swift
+enum E {
+  case foo, bar
+}
+func foo(_ arg: E) {}
+func test(val: E) {
+  foo(.bar)
+  if v
+}
+
+// BEGIN dummy.swift
+
+// rdar://75358153
+// Previously, completing inside single expression body, then completing inside
+// *non* single expression body in the same function caused a crash because the
+// "has single expression" flag didn't cleard. This file tests the scenario not
+// to regress again.
+
+// RUN: %empty-directory(%t)
+// RUN: %{python} %utils/split_file.py -o %t %s
+
+// RUN: %sourcekitd-test \
+// RUN:   -req=complete -pos=6:8 -text-input %t/t1.swift %t/t.swift -- %t/t.swift == \
+// RUN:   -req=complete -pos=7:6 -text-input %t/t2.swift %t/t.swift -- %t/t.swift \
+// RUN: | %FileCheck %s
+
+// CHECK-LABEL: key.results: [
+// CHECK-DAG: key.description: "bar",
+// CHECK-DAG: key.description: "foo",
+// CHECK-DAG: key.description: "hash(self: E)",
+// CHECK: ]
+// CHECK-NOT: key.reusingastcontext: 1
+
+// CHECK-LABEL: key.results: [
+// CHECK-DAG: key.description: "val",
+// CHECK-DAG: key.description: "foo(arg: E)",
+// CHECK: ],
+// CHECK: key.reusingastcontext: 1
diff --git a/test/SourceKit/CursorInfo/missing_module_map.swift b/test/SourceKit/CursorInfo/missing_module_map.swift
@@ -0,0 +1,9 @@
+// RUN: %empty-directory(%t.mcp)
+// RUN: %sourcekitd-test -req=cursor -pos=6:9 %s -- -Xcc -fmodule-map-file=/some/missing/file -module-cache-path %t.mcp %s | %FileCheck %s
+
+// We used to fail to load the stdlib if there is a `-fmodule-map-file` option pointing to a missing file
+
+let x: String = "abc"
+// CHECK: source.lang.swift.ref.struct ()
+// CHECK: String
+// CHECK: s:SS
diff --git a/tools/SourceKit/lib/SwiftLang/SwiftASTManager.cpp b/tools/SourceKit/lib/SwiftLang/SwiftASTManager.cpp
@@ -848,6 +848,11 @@ ASTUnitRef ASTProducer::createASTUnit(
     Error = "compilation setup failed";
     return nullptr;
   }
+  if (CompIns.loadStdlibIfNeeded()) {
+    LOG_WARN_FUNC("Loading the stdlib failed");
+    Error = "Loading the stdlib failed";
+    return nullptr;
+  }
   registerIDERequestFunctions(CompIns.getASTContext().evaluator);
   if (TracedOp.enabled()) {
     TracedOp.start(TraceInfo);
diff --git a/validation-test/ClangImporter/memcmp-definitions.swift b/validation-test/ClangImporter/memcmp-definitions.swift
@@ -0,0 +1,12 @@
+/// rdar://69876253
+// REQUIRES: VENDOR=apple
+// RUN: %target-build-swift %s -o %t.out
+
+import SwiftShims
+import Foundation
+
+func foo () {
+  let a = UnsafeMutableRawPointer.allocate(byteCount: 4, alignment: 4)
+  let b = UnsafeMutableRawPointer.allocate(byteCount: 4, alignment: 4)
+  memcmp(a, b, 4)
+}

Original file line number	Diff line number	Diff line change
`@@ -1632,7 +1632,8 @@ bool IRGenModule::useDllStorage() { return ::useDllStorage(Triple); }`
`1632`	`1632`
`1633`	`1633`	`bool IRGenModule::shouldPrespecializeGenericMetadata() {`
`1634`	`1634`	`auto canPrespecializeTarget =`
`1635`		`- (Triple.isOSDarwin() \|\| Triple.isTvOS() \|\| Triple.isOSLinux());`
	`1635`	`+ (Triple.isOSDarwin() \|\| Triple.isTvOS() \|\|`
	`1636`	`+ (Triple.isOSLinux() && !(Triple.isARM() && Triple.isArch32Bit())));`
`1636`	`1637`	`if (canPrespecializeTarget && isStandardLibrary()) {`
`1637`	`1638`	`return true;`
`1638`	`1639`	`}`