Fix build issue after merging master

docs/libFuzzerIntegration.md

@@ -1,37 +1,39 @@
-libFuzzer Integration
----------------------
-
-Swift compiler comes with a built-in `libFuzzer` integration.
-In order to use it on a file `myfile.swift`, we define an entry point fuzzing function
-with a `@_cdecl("LLVMFuzzerTestOneInput")` annotation:
+# libFuzzer Integration
 
+Custom builds of the Swift toolchain (including development snapshots)
+have a built-in `libFuzzer` integration. In order to use it on a file
+`myfile.swift`, define an entry point fuzzing function with a
+`@_cdecl("LLVMFuzzerTestOneInput")` annotation:
 
 ```swift
-@_cdecl("LLVMFuzzerTestOneInput") public func fuzzMe(Data: UnsafePointer<CChar>, Size: CInt) -> CInt{
-    // Test our code using provided Data.
-  }
+@_cdecl("LLVMFuzzerTestOneInput")
+public func test(_ start: UnsafeRawPointer, _ count: Int) -> CInt {
+  let bytes = UnsafeRawBufferPointer(start: start, count: count)
+  // TODO: Test the code using the provided bytes.
+  return 0
 }
 ```
 
-To compile it, we use `-sanitize=fuzzer` flag to link `libFuzzer`
-and enable coverage annotation, and `-parse-as-library` flag not to insert
-the `main` symbol, such that the fuzzer entry point can be used:
+To compile it, use the `-sanitize=fuzzer` flag to link `libFuzzer`
+and enable code coverage information; and the `-parse-as-library` flag
+to omit the `main` symbol, so that the fuzzer entry point can be used:
 
 ```bash
 % swiftc -sanitize=fuzzer -parse-as-library myfile.swift
 ```
 
-`libFuzzer` can be also combined with other sanitizers:
+`libFuzzer` can be combined with other sanitizers:
 
 ```bash
 % swiftc -sanitize=fuzzer,address -parse-as-library myfile.swift
 ```
 
-Finally, we launch the fuzzing process:
+Finally, launch the fuzzing process:
 
 ```bash
-% ./a.out
+% ./myfile
 ```
 
-Refer to the official `libFuzzer` documentation at http://llvm.org/docs/LibFuzzer.html
-for the description of flags the resulting binary has.
+Refer to the official `libFuzzer` documentation at
+<https://llvm.org/docs/LibFuzzer.html#options>
+for a description of the fuzzer's command line options.

include/swift/AST/DiagnosticsSema.def

@@ -250,6 +250,9 @@ ERROR(no_candidates_match_result_type,none,
       "no '%0' candidates produce the expected contextual result type %1",
       (StringRef, Type))
 
+ERROR(cannot_infer_closure_parameter_type,none,
+      "unable to infer type of a closure parameter %0 in the current context",
+       (StringRef))
 ERROR(cannot_infer_closure_type,none,
       "unable to infer closure type in the current context", ())
 ERROR(cannot_infer_closure_result_type,none,

include/swift/AST/ModuleDependencies.h

@@ -68,6 +68,13 @@ class SwiftModuleDependenciesStorage : public ModuleDependenciesStorageBase {
   /// The Swift interface file, if it can be used to generate the module file.
   const Optional<std::string> swiftInterfaceFile;
 
+  /// The Swift frontend invocation arguments to build the Swift module from the
+  /// interface.
+  const std::vector<std::string> buildCommandLine;
+
+  /// The hash value that will be used for the generated module
+  const std::string contextHash;
+
   /// Bridging header file, if there is one.
   Optional<std::string> bridgingHeaderFile;
 
@@ -82,9 +89,13 @@ class SwiftModuleDependenciesStorage : public ModuleDependenciesStorageBase {
 
   SwiftModuleDependenciesStorage(
       const std::string &compiledModulePath,
-      const Optional<std::string> &swiftInterfaceFile
+      const Optional<std::string> &swiftInterfaceFile,
+      ArrayRef<StringRef> buildCommandLine,
+      StringRef contextHash
   ) : ModuleDependenciesStorageBase(/*isSwiftModule=*/true, compiledModulePath),
-      swiftInterfaceFile(swiftInterfaceFile) { }
+      swiftInterfaceFile(swiftInterfaceFile),
+      buildCommandLine(buildCommandLine.begin(), buildCommandLine.end()),
+      contextHash(contextHash) { }
 
   ModuleDependenciesStorageBase *clone() const override {
     return new SwiftModuleDependenciesStorage(*this);
@@ -162,18 +173,20 @@ class ModuleDependencies {
   /// built from a Swift interface file (\c .swiftinterface).
   static ModuleDependencies forSwiftInterface(
       const std::string &compiledModulePath,
-      const std::string &swiftInterfaceFile) {
+      const std::string &swiftInterfaceFile,
+      ArrayRef<StringRef> buildCommands,
+      StringRef contextHash) {
     return ModuleDependencies(
         std::make_unique<SwiftModuleDependenciesStorage>(
-          compiledModulePath, swiftInterfaceFile));
+          compiledModulePath, swiftInterfaceFile, buildCommands, contextHash));
   }
 
   /// Describe the module dependencies for a serialized or parsed Swift module.
   static ModuleDependencies forSwiftModule(
       const std::string &compiledModulePath) {
     return ModuleDependencies(
         std::make_unique<SwiftModuleDependenciesStorage>(
-          compiledModulePath, None));
+          compiledModulePath, None, ArrayRef<StringRef>(), StringRef()));
   }
 
   /// Describe the module dependencies for a Clang module that can be

include/swift/AST/ModuleLoader.h

@@ -89,6 +89,8 @@ class DependencyTracker {
 struct SubCompilerInstanceInfo {
   StringRef CompilerVersion;
   CompilerInstance* Instance;
+  StringRef Hash;
+  ArrayRef<StringRef> BuildArguments;
 };
 
 /// Abstract interface to run an action in a sub ASTContext.
@@ -97,7 +99,7 @@ struct InterfaceSubContextDelegate {
                                StringRef interfacePath,
                                StringRef outputPath,
                                SourceLoc diagLoc,
-                               llvm::function_ref<bool(ASTContext&)> action) = 0;
+  llvm::function_ref<bool(ASTContext&,ArrayRef<StringRef>, StringRef)> action) = 0;
   virtual bool runInSubCompilerInstance(StringRef moduleName,
                                         StringRef interfacePath,
                                         StringRef outputPath,

include/swift/Basic/STLExtras.h

@@ -71,6 +71,7 @@ struct function_traits<R (T::*)(Args...) const> {
 
 } // end namespace swift
 
+#if !defined(swiftCore_EXPORTS)
 namespace llvm {
 
 /// @{
@@ -109,6 +110,7 @@ inline void interleave(const Container &c, UnaryFunctor each_fn,
 /// @}
 
 } // end namespace llvm
+#endif
 
 namespace swift {
 

include/swift/Demangling/Demangler.h

@@ -565,8 +565,7 @@ class Demangler : public NodeFactory {
   NodePointer demangleValueWitness();
 
   NodePointer demangleTypeMangling();
-  NodePointer demangleSymbolicReference(unsigned char rawKind,
-                                        const void *at);
+  NodePointer demangleSymbolicReference(unsigned char rawKind);
 
   bool demangleBoundGenerics(Vector<NodePointer> &TypeListList,
                              NodePointer &RetroactiveConformances);

include/swift/Frontend/ModuleInterfaceLoader.h

@@ -208,7 +208,11 @@ struct InterfaceSubContextDelegateImpl: InterfaceSubContextDelegate {
 private:
   SourceManager &SM;
   DiagnosticEngine &Diags;
+  llvm::BumpPtrAllocator Allocator;
+  llvm::StringSaver ArgSaver;
+  std::vector<StringRef> GenericArgs;
   CompilerInvocation subInvocation;
+  std::vector<SupplementaryOutputPaths> ModuleOutputPaths;
 
   template<typename ...ArgTypes>
   InFlightDiagnostic diagnose(StringRef interfacePath,
@@ -222,45 +226,43 @@ struct InterfaceSubContextDelegateImpl: InterfaceSubContextDelegate {
     }
     return Diags.diagnose(loc, ID, std::move(Args)...);
   }
-
-  bool extractSwiftInterfaceVersionAndArgs(llvm::StringSaver &SubArgSaver,
-                                           SmallVectorImpl<const char *> &SubArgs,
+  void inheritOptionsForBuildingInterface(const SearchPathOptions &SearchPathOpts,
+                                          const LangOptions &LangOpts);
+  bool extractSwiftInterfaceVersionAndArgs(SmallVectorImpl<const char *> &SubArgs,
                                            std::string &CompilerVersion,
                                            StringRef interfacePath,
                                            SourceLoc diagnosticLoc);
-  SubCompilerInstanceInfo createInstance(StringRef moduleName,
-                                         StringRef interfacePath,
-                                         StringRef outputPath,
-                                         SourceLoc diagLoc);
 public:
   InterfaceSubContextDelegateImpl(SourceManager &SM,
                                   DiagnosticEngine &Diags,
                                   const SearchPathOptions &searchPathOpts,
                                   const LangOptions &langOpts,
-                                  ClangModuleLoader *clangImporter = nullptr,
-                                  StringRef moduleCachePath = StringRef(),
-                                  StringRef prebuiltCachePath = StringRef(),
-                                  bool serializeDependencyHashes = false,
-                                  bool trackSystemDependencies = false,
-                                  bool remarkOnRebuildFromInterface = false,
-                                  bool disableInterfaceFileLock = false);
+                                  ClangModuleLoader *clangImporter,
+                                  bool buildModuleCacheDirIfAbsent,
+                                  StringRef moduleCachePath,
+                                  StringRef prebuiltCachePath,
+                                  bool serializeDependencyHashes,
+                                  bool trackSystemDependencies,
+                                  bool remarkOnRebuildFromInterface,
+                                  bool disableInterfaceFileLock);
   bool runInSubContext(StringRef moduleName,
                        StringRef interfacePath,
                        StringRef outputPath,
                        SourceLoc diagLoc,
-                       llvm::function_ref<bool(ASTContext&)> action) override;
+    llvm::function_ref<bool(ASTContext&, ArrayRef<StringRef>, StringRef)> action) override;
   bool runInSubCompilerInstance(StringRef moduleName,
                                 StringRef interfacePath,
                                 StringRef outputPath,
                                 SourceLoc diagLoc,
-                                llvm::function_ref<bool(SubCompilerInstanceInfo&)> action) override;
+            llvm::function_ref<bool(SubCompilerInstanceInfo&)> action) override;
 
   ~InterfaceSubContextDelegateImpl() = default;
 
   /// includes a hash of relevant key data.
-  void computeCachedOutputPath(StringRef moduleName,
-                               StringRef UseInterfacePath,
-                               llvm::SmallString<256> &OutPath);
+  StringRef computeCachedOutputPath(StringRef moduleName,
+                                    StringRef UseInterfacePath,
+                                    llvm::SmallString<256> &OutPath,
+                                    StringRef &CacheHash);
   std::string getCacheHash(StringRef useInterfacePath);
 };
 }

include/swift/Runtime/Concurrent.h

@@ -203,7 +203,7 @@ class ConcurrentMapBase<EntryTy, false, Allocator> : protected Allocator {
 
     // Deallocate the node.  The static_cast here is required
     // because LLVM's allocator API is insane.
-    this->Deallocate(static_cast<void*>(node), allocSize);
+    this->Deallocate(static_cast<void*>(node), allocSize, alignof(Node));
   }
 };
 

lib/AST/GenericSignatureBuilder.cpp

@@ -2542,7 +2542,13 @@ static void concretizeNestedTypeFromConcreteParent(
     GenericSignatureBuilder &builder) {
   auto parentEquiv = parent->getEquivalenceClassIfPresent();
   assert(parentEquiv && "can't have a concrete type without an equiv class");
+
+  bool isSuperclassConstrained = false;
   auto concreteParent = parentEquiv->concreteType;
+  if (!concreteParent) {
+    isSuperclassConstrained = true;
+    concreteParent = parentEquiv->superclass;
+  }
   assert(concreteParent &&
          "attempting to resolve concrete nested type of non-concrete PA");
 
@@ -2564,8 +2570,14 @@ static void concretizeNestedTypeFromConcreteParent(
          "No conformance requirement");
   const RequirementSource *parentConcreteSource = nullptr;
   for (const auto &constraint : parentEquiv->conformsTo.find(proto)->second) {
-    if (constraint.source->kind == RequirementSource::Concrete) {
-      parentConcreteSource = constraint.source;
+    if (!isSuperclassConstrained) {
+      if (constraint.source->kind == RequirementSource::Concrete) {
+        parentConcreteSource = constraint.source;
+      }
+    } else {
+      if (constraint.source->kind == RequirementSource::Superclass) {
+        parentConcreteSource = constraint.source;
+      }
     }
   }
 
@@ -4299,6 +4311,15 @@ bool GenericSignatureBuilder::updateSuperclass(
     for (const auto &conforms : equivClass->conformsTo) {
       (void)resolveSuperConformance(type, conforms.first);
     }
+
+    // Eagerly resolve any existing nested types to their concrete forms (others
+    // will be "concretized" as they are constructed, in getNestedType).
+    for (auto equivT : equivClass->members) {
+      for (auto nested : equivT->getNestedTypes()) {
+        concretizeNestedTypeFromConcreteParent(equivT, nested.second.front(),
+                                               *this);
+      }
+    }
   };
 
   // If we haven't yet recorded a superclass constraint for this equivalence
@@ -7188,6 +7209,12 @@ void GenericSignatureBuilder::dump(llvm::raw_ostream &out) {
     pa->dump(out, &Context.SourceMgr, 2);
   }
   out << "\n";
+
+  out << "Equivalence classes:\n";
+  for (auto &equiv : Impl->EquivalenceClasses) {
+    equiv.dump(out, this);
+  }
+  out << "\n";
 }
 
 void GenericSignatureBuilder::addGenericSignature(GenericSignature sig) {

lib/AST/Type.cpp

@@ -3521,24 +3521,28 @@ static Type getMemberForBaseType(LookupConformanceFn lookupConformances,
 
     // Retrieve the type witness.
     auto witness =
-        conformance.getConcrete()->getTypeWitness(assocType, options);
-    if (!witness || witness->hasError())
+        conformance.getConcrete()->getTypeWitnessAndDecl(assocType, options);
+
+    auto witnessTy = witness.getWitnessType();
+    if (!witnessTy || witnessTy->hasError())
       return failed();
 
     // This is a hacky feature allowing code completion to migrate to
     // using Type::subst() without changing output.
     if (options & SubstFlags::DesugarMemberTypes) {
-      if (auto *aliasType =
-                   dyn_cast<TypeAliasType>(witness.getPointer())) {
-        if (!aliasType->is<ErrorType>())
-          witness = aliasType->getSinglyDesugaredType();
-      }
+      if (auto *aliasType = dyn_cast<TypeAliasType>(witnessTy.getPointer()))
+        witnessTy = aliasType->getSinglyDesugaredType();
+
+      // Another hack. If the type witness is a opaque result type. They can
+      // only be referred using the name of the associated type.
+      if (witnessTy->is<OpaqueTypeArchetypeType>())
+        witnessTy = witness.getWitnessDecl()->getDeclaredInterfaceType();
     }
 
-    if (witness->is<ErrorType>())
+    if (witnessTy->is<ErrorType>())
       return failed();
 
-    return witness;
+    return witnessTy;
   }
 
   return failed();

lib/Demangling/Demangler.cpp

@@ -677,12 +677,14 @@ NodePointer Demangler::demangleTypeMangling() {
   return TypeMangling;
 }
 
-NodePointer Demangler::demangleSymbolicReference(unsigned char rawKind,
-                                                 const void *at) {
+NodePointer Demangler::demangleSymbolicReference(unsigned char rawKind) {
   // The symbolic reference is a 4-byte machine integer encoded in the following
   // four bytes.
+  if (Pos + 4 > Text.size())
+    return nullptr;
+  const void *at = Text.data() + Pos;
   int32_t value;
-  memcpy(&value, Text.data() + Pos, 4);
+  memcpy(&value, at, 4);
   Pos += 4;
 
   // Map the encoded kind to a specific kind and directness.
@@ -734,7 +736,7 @@ NodePointer Demangler::demangleOperator() {
       goto recur;
     case 1: case 2:   case 3:   case 4:   case 5: case 6: case 7: case 8:
     case 9: case 0xA: case 0xB: case 0xC:
-      return demangleSymbolicReference((unsigned char)c, Text.data() + Pos);
+      return demangleSymbolicReference((unsigned char)c);
     case 'A': return demangleMultiSubstitutions();
     case 'B': return demangleBuiltinType();
     case 'C': return demangleAnyGenericType(Node::Kind::Class);

lib/Frontend/ModuleInterfaceBuilder.cpp

@@ -163,8 +163,10 @@ bool ModuleInterfaceBuilder::buildSwiftModuleInternal(
       llvm::RestorePrettyStackState(savedInnerPrettyStackState);
     };
 
-    SubError = subASTDelegate.runInSubCompilerInstance(moduleName, interfacePath,
-                                                       OutPath, diagnosticLoc,
+    SubError = subASTDelegate.runInSubCompilerInstance(moduleName,
+                                                       interfacePath,
+                                                       OutPath,
+                                                       diagnosticLoc,
                                            [&](SubCompilerInstanceInfo &info) {
     auto &SubInstance = *info.Instance;
     auto subInvocation = SubInstance.getInvocation();