[pull] swiftwasm from apple:master

cmake/modules/AddSwift.cmake

@@ -2133,7 +2133,10 @@ function(add_swift_target_library name)
 
         list(APPEND swiftlib_swift_compile_flags_all "-Fsystem" "${ios_support_frameworks_path}")
         list(APPEND swiftlib_c_compile_flags_all "-iframework" "${ios_support_frameworks_path}")
-        list(APPEND swiftlib_link_flags_all "-F" "${ios_support_frameworks_path}")
+        # We collate -F with the framework path to avoid unwanted deduplication
+        # of options by target_compile_options -- this way no undesired
+        # side effects are introduced should a new search path be added.
+        list(APPEND swiftlib_link_flags_all "-F${ios_support_frameworks_path}")
       endif()
 
       if(sdk IN_LIST SWIFT_APPLE_PLATFORMS AND SWIFTLIB_IS_SDK_OVERLAY)

include/swift/AST/DiagnosticsSema.def

@@ -338,6 +338,10 @@ ERROR(cannot_convert_initializer_value,none,
       "cannot convert value of type %0 to specified type %1", (Type,Type))
 ERROR(cannot_convert_initializer_value_protocol,none,
       "value of type %0 does not conform to specified type %1", (Type,Type))
+ERROR(cannot_convert_initializer_value_anyobject,none,
+      "value of type %0 expected to be instance of class or "
+      "class-constrained type",
+      (Type, Type))
 ERROR(cannot_convert_initializer_value_nil,none,
       "'nil' cannot initialize specified type %0", (Type))
 
@@ -346,6 +350,10 @@ ERROR(cannot_convert_to_return_type,none,
       (Type,Type))
 ERROR(cannot_convert_to_return_type_protocol,none,
       "return expression of type %0 does not conform to %1", (Type,Type))
+ERROR(cannot_convert_return_type_to_anyobject,none,
+      "return expression of type %0 expected to be an instance of "
+      "a class or class-constrained type",
+      (Type, Type))
 ERROR(cannot_convert_to_return_type_nil,none,
       "'nil' is incompatible with return type %0", (Type))
 
@@ -440,7 +448,10 @@ NOTE(candidate_performs_illegal_ephemeral_conv,none,
 
 ERROR(cannot_convert_argument_value_protocol,none,
       "argument type %0 does not conform to expected type %1", (Type, Type))
-
+ERROR(cannot_convert_argument_value_anyobject,none,
+      "argument type %0 expected to be an instance of "
+      "a class or class-constrained type",
+      (Type, Type))
 ERROR(cannot_convert_argument_value_nil,none,
       "'nil' is not compatible with expected argument type %0", (Type))
 
@@ -536,6 +547,10 @@ NOTE(assign_protocol_conformance_fix_it,none,
 ERROR(cannot_convert_assign_protocol,none,
       "value of type %0 does not conform to %1 in assignment",
       (Type, Type))
+ERROR(cannot_convert_assign_anyobject,none,
+      "value of type %0 expected to be an instance of "
+      "a class or class-constrained type in assignment",
+      (Type, Type))
 ERROR(cannot_convert_assign_nil,none,
       "'nil' cannot be assigned to type %0", (Type))
 

include/swift/AST/FineGrainedDependencies.h

@@ -799,6 +799,7 @@ class SourceFileDepGraph {
                    compoundNamesByRDK);
 
   static constexpr char noncascadingOrPrivatePrefix = '#';
+  static constexpr char nameFingerprintSeparator = ',';
 
   static std::string noncascading(std::string name);
 

include/swift/Basic/SourceManager.h

@@ -243,6 +243,9 @@ class SourceManager {
   llvm::Optional<unsigned> resolveOffsetForEndOfLine(unsigned BufferId,
                                                      unsigned Line) const;
 
+  /// Get the length of the line
+  llvm::Optional<unsigned> getLineLength(unsigned BufferId, unsigned Line) const;
+
   SourceLoc getLocForLineCol(unsigned BufferId, unsigned Line, unsigned Col) const {
     auto Offset = resolveFromLineCol(BufferId, Line, Col);
     return Offset.hasValue() ? getLocForOffset(BufferId, Offset.getValue()) :

include/swift/Driver/FineGrainedDependencyDriverGraph.h

@@ -437,7 +437,7 @@ class ModuleDepGraph {
   /// Call \p fn for each node whose key matches \p key.
   void
   forEachMatchingNode(const DependencyKey &key,
-                      function_ref<void(const ModuleDepGraphNode *)>) const;
+                      function_ref<void(ModuleDepGraphNode *)>) const;
 
   void forEachNodeInJob(StringRef swiftDeps,
                         function_ref<void(ModuleDepGraphNode *)>) const;

include/swift/Option/Options.td

@@ -191,7 +191,7 @@ HelpText<"Emit dot files every time driver imports an fine-grained swiftdeps fil
 
 def fine_grained_dependency_include_intrafile :
 Flag<["-"], "fine-grained-dependency-include-intrafile">,
-InternalDebugOpt,
+Flags<[FrontendOption, HelpHidden]>,
 HelpText<"Include within-file dependencies.">;
 
 def emit_fine_grained_dependency_sourcefile_dot_files :

include/swift/SILOptimizer/Analysis/EscapeAnalysis.h

@@ -449,7 +449,7 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
 
     /// Sets the outgoing points-to edge. The \p To node must be a Content node.
     void setPointsToEdge(CGNode *To) {
-      assert(!To->mergeTo);
+      assert(!To->isMerged);
       assert(To->Type == NodeType::Content &&
              "Wrong node type for points-to edge");
       pointsToIsEdge = true;

lib/AST/FineGrainedDependenciesSourceFileDepGraphConstructor.cpp

@@ -680,12 +680,10 @@ class SourceFileDepGraphConstructor {
     for (const auto &contextNameFingerprint : contextNameFingerprints) {
       auto p = g.findExistingNodePairOrCreateAndAddIfNew(
           kind, contextNameFingerprint);
-      // When we don't have a fingerprint yet, must rebuild every provider when
-      // interfaceHash changes. So when interface (i.e. interface hash) of
-      // sourceFile changes, every provides is dirty. And since we don't know
-      // what happened, dirtyness might affect the interface.
-      if (!p.getInterface()->getFingerprint().hasValue())
-        g.addArc(g.getSourceFileNodePair().getInterface(), p.getInterface());
+      // Since the current type fingerprints only include tokens in the body,
+      // when the interface hash changes, it is possible that the type in the
+      // file has changed.
+      g.addArc(g.getSourceFileNodePair().getInterface(), p.getInterface());
     }
   }
 
@@ -809,8 +807,15 @@ bool swift::fine_grained_dependencies::emitReferenceDependencies(
   // that may have been there. No error handling -- this is just a nicety, it
   // doesn't matter if it fails.
   llvm::sys::fs::rename(outputPath, outputPath + "~");
+  // Since, when fingerprints are enabled,
+  // the parser diverts token hashing into per-body fingerprints
+  // before it can know if a difference is in a private type,
+  // in order to be able to test the changed  fingerprints
+  // we force the inclusion of private declarations when fingerprints
+  // are enabled.
   const bool includeIntrafileDeps =
-      SF->getASTContext().LangOpts.FineGrainedDependenciesIncludeIntrafileOnes;
+    SF->getASTContext().LangOpts.FineGrainedDependenciesIncludeIntrafileOnes ||
+    SF->getASTContext().LangOpts.EnableTypeFingerprints;
   const bool hadCompilationError = SF->getASTContext().hadError();
   auto gc = SourceFileDepGraphConstructor::forSourceFile(
       SF, depTracker, outputPath, includeIntrafileDeps, hadCompilationError);
@@ -843,33 +848,54 @@ bool swift::fine_grained_dependencies::emitReferenceDependencies(
 static StringRef stripPrefix(const StringRef name) {
   return name.ltrim(SourceFileDepGraph::noncascadingOrPrivatePrefix);
 }
+static StringRef stripFingerprint(const StringRef nameAndFingerprint) {
+  return nameAndFingerprint.split(SourceFileDepGraph::nameFingerprintSeparator)
+           .first;
+}
+static StringRef stripName(const StringRef nameAndFingerprint) {
+  return nameAndFingerprint.split(SourceFileDepGraph::nameFingerprintSeparator)
+           .second;
+}
+static std::string extractName(const StringRef prefixNameFingerprint) {
+  return stripFingerprint(stripPrefix(prefixNameFingerprint)).str();
+}
+static Optional<std::string> extractFingerprint(
+         const StringRef prefixNameFingerprint) {
+  const auto fp = stripName(stripPrefix(prefixNameFingerprint));
+  return fp.empty() ? None : Optional<std::string>(fp.str());
+}
 
 static std::vector<ContextNameFingerprint>
 getBaseNameProvides(ArrayRef<std::string> simpleNames) {
   std::vector<ContextNameFingerprint> result;
   for (StringRef n : simpleNames)
-    result.push_back(ContextNameFingerprint("", stripPrefix(n).str(), None));
+    result.push_back(ContextNameFingerprint("", extractName(n),
+                     extractFingerprint(n)));
   return result;
 }
 
 static std::vector<ContextNameFingerprint>
 getMangledHolderProvides(ArrayRef<std::string> simpleNames) {
   std::vector<ContextNameFingerprint> result;
   for (StringRef n : simpleNames)
-    result.push_back(ContextNameFingerprint(stripPrefix(n).str(), "", None));
+    result.push_back(ContextNameFingerprint(extractName(n), "",
+                     extractFingerprint(n)));
   return result;
 }
 
 static std::vector<ContextNameFingerprint> getCompoundProvides(
     ArrayRef<std::pair<std::string, std::string>> compoundNames) {
   std::vector<ContextNameFingerprint> result;
   for (const auto &p : compoundNames)
-    result.push_back(ContextNameFingerprint(stripPrefix(p.first),
-                                            stripPrefix(p.second), None));
+    result.push_back(ContextNameFingerprint(extractName(p.first),
+                                            extractName(p.second),
+                                            extractFingerprint(p.second)));
   return result;
 }
 
-static bool cascades(const std::string &s) { return s.empty() || s[0] != SourceFileDepGraph::noncascadingOrPrivatePrefix; }
+static bool cascades(const std::string &s) {
+  return s.empty() || s[0] != SourceFileDepGraph::noncascadingOrPrivatePrefix;
+}
 
 // Use '_' as a prefix for a file-private member
 static bool isPrivate(const std::string &s) {
@@ -899,7 +925,8 @@ getCompoundDepends(
     // (On Linux, the compiler needs more verbosity than:
     //  result.push_back({{n, "", false}, cascades(n)});
     result.push_back(
-        std::make_pair(std::make_tuple(stripPrefix(n), std::string(), false), cascades(n)));
+        std::make_pair(std::make_tuple(stripPrefix(n), std::string(), false),
+                       cascades(n)));
   }
   for (auto &p : compoundNames) {
     // Likewise, for Linux expand the following out:
@@ -927,7 +954,8 @@ SourceFileDepGraph SourceFileDepGraph::simulateLoad(
   SourceFileDepGraphConstructor c(
     swiftDepsFilename, includePrivateDeps, hadCompilationError, interfaceHash,
     getSimpleDepends(simpleNamesByRDK[dependsTopLevel]),
-    getCompoundDepends(simpleNamesByRDK[dependsNominal], compoundNamesByRDK[dependsMember]),
+    getCompoundDepends(simpleNamesByRDK[dependsNominal],
+                       compoundNamesByRDK[dependsMember]),
     getSimpleDepends(simpleNamesByRDK[dependsDynamicLookup]),
     getExternalDepends(simpleNamesByRDK[dependsExternal]),
     {}, // precedence groups

lib/Basic/CMakeLists.txt

@@ -11,32 +11,59 @@ else()
   set(UUID_INCLUDE "${UUID_INCLUDE_DIRS}")
 endif()
 
-function(generate_revision_inc revision_inc_var name dir)
-  find_first_existing_vc_file("${dir}" ${name}_vc)
+# Figure out if we can track VC revisions.
+# FIXME: Copied from Clang.
+function(find_first_existing_file out_var)
+  foreach(file ${ARGN})
+    if(EXISTS "${file}")
+      set(${out_var} "${file}" PARENT_SCOPE)
+      return()
+    endif()
+  endforeach()
+endfunction()
 
-  # Create custom target to generate the VC revision include.
-  set(version_inc "${CMAKE_CURRENT_BINARY_DIR}/${name}Revision.inc")
+macro(find_first_existing_vc_file out_var path)
+  find_first_existing_file(${out_var}
+    "${path}/.git/logs/HEAD" # Git
+    "${path}/.svn/wc.db"     # SVN 1.7
+    "${path}/.svn/entries"   # SVN 1.6
+    )
+endmacro()
 
-  set(generate_vcs_version_script "${LLVM_MAIN_SRC_DIR}/cmake/modules/GenerateVersionFromVCS.cmake")
+set(generate_vcs_version_script "${LLVM_MAIN_SRC_DIR}/cmake/modules/GenerateVersionFromVCS.cmake")
 
-  add_custom_command(OUTPUT "${version_inc}"
-    DEPENDS "${${name}_vc}" "${generate_vcs_version_script}"
-    COMMAND ${CMAKE_COMMAND} "-DNAMES=$<UPPER_CASE:name>"
-                             "-D$<UPPER_CASE:name>_SOURCE_DIR=${dir}"
-                             "-DHEADER_FILE=${version_inc}"
-                             -P "${generate_vcs_version_script}")
+function(generate_revision_inc revision_inc_var name dir)
+  find_first_existing_vc_file(dep_file "${dir}")
+  # Create custom target to generate the VC revision include.
+  set(revision_inc "${CMAKE_CURRENT_BINARY_DIR}/${name}Revision.inc")
+  string(TOUPPER ${name} upper_name)
+  if(DEFINED dep_file)
+    add_custom_command(OUTPUT "${revision_inc}"
+      DEPENDS "${dep_file}" "${generate_vcs_version_script}"
+      COMMAND
+      ${CMAKE_COMMAND} "-DNAMES=${upper_name}"
+                       "-D${upper_name}_SOURCE_DIR=${dir}"
+                       "-DHEADER_FILE=${revision_inc}"
+                       -P "${generate_vcs_version_script}")
+  else()
+    # Generate an empty Revision.inc file if we are not using git or SVN.
+    file(WRITE "${revision_inc}" "")
+  endif()
 
   # Mark the generated header as being generated.
-  set_source_files_properties("${version_inc}"
+  set_source_files_properties("${revision_inc}"
     PROPERTIES GENERATED TRUE
                HEADER_FILE_ONLY TRUE)
-  set(${revision_inc_var} ${version_inc} PARENT_SCOPE)
+  set(${revision_inc_var} ${revision_inc} PARENT_SCOPE)
 endfunction()
 
 generate_revision_inc(llvm_revision_inc LLVM "${LLVM_MAIN_SRC_DIR}")
 generate_revision_inc(clang_revision_inc Clang "${CLANG_MAIN_SRC_DIR}")
 generate_revision_inc(swift_revision_inc Swift "${SWIFT_SOURCE_DIR}")
 
+set(version_inc_files
+  ${llvm_revision_inc} ${clang_revision_inc} ${swift_revision_inc})
+
 add_swift_host_library(swiftBasic STATIC
   AnyValue.cpp
   Cache.cpp
@@ -68,10 +95,7 @@ add_swift_host_library(swiftBasic STATIC
   Unicode.cpp
   UUID.cpp
   Version.cpp
-
-  ${llvm_revision_inc}
-  ${clang_revision_inc}
-  ${swift_revision_inc}
+  ${version_inc_files}
 
   # Platform-specific TaskQueue implementations
   Unix/TaskQueue.inc

lib/Basic/SourceLoc.cpp

@@ -331,10 +331,20 @@ SourceManager::resolveOffsetForEndOfLine(unsigned BufferId,
   return resolveFromLineCol(BufferId, Line, ~0u);
 }
 
+llvm::Optional<unsigned>
+SourceManager::getLineLength(unsigned BufferId, unsigned Line) const {
+  auto BegOffset = resolveFromLineCol(BufferId, Line, 0);
+  auto EndOffset = resolveFromLineCol(BufferId, Line, ~0u);
+  if (BegOffset && EndOffset) {
+     return EndOffset.getValue() - BegOffset.getValue();
+  }
+  return None;
+}
+
 llvm::Optional<unsigned> SourceManager::resolveFromLineCol(unsigned BufferId,
                                                            unsigned Line,
                                                            unsigned Col) const {
-  if (Line == 0 || Col == 0) {
+  if (Line == 0) {
     return None;
   }
   const bool LineEnd = Col == ~0u;
@@ -353,6 +363,9 @@ llvm::Optional<unsigned> SourceManager::resolveFromLineCol(unsigned BufferId,
     return None;
   }
   Ptr = LineStart;
+  if (Col == 0)   {
+      return Ptr - InputBuf->getBufferStart();
+  }
   // The <= here is to allow for non-inclusive range end positions at EOF
   for (; ; ++Ptr) {
     --Col;

lib/Driver/FineGrainedDependencyDriverGraph.cpp

@@ -171,6 +171,11 @@ ModuleDepGraph::findJobsToRecompileWhenNodesChange<
     std::unordered_set<ModuleDepGraphNode *>>(
     const std::unordered_set<ModuleDepGraphNode *> &);
 
+template std::vector<const Job *>
+ModuleDepGraph::findJobsToRecompileWhenNodesChange<
+    std::vector<ModuleDepGraphNode *>>(
+    const std::vector<ModuleDepGraphNode *> &);
+
 std::vector<std::string> ModuleDepGraph::computeSwiftDepsFromNodes(
     ArrayRef<const ModuleDepGraphNode *> nodes) const {
   llvm::StringSet<> swiftDepsOfNodes;
@@ -441,7 +446,7 @@ void ModuleDepGraph::forEachNode(
 
 void ModuleDepGraph::forEachMatchingNode(
     const DependencyKey &key,
-    function_ref<void(const ModuleDepGraphNode *)> fn) const {
+    function_ref<void(ModuleDepGraphNode *)> fn) const {
   nodeMap.forEachValueMatching(
       key, [&](const std::string &, ModuleDepGraphNode *n) { fn(n); });
 }

lib/SIL/SILPrinter.cpp

@@ -64,6 +64,10 @@ llvm::cl::opt<bool>
 SILPrintDebugInfo("sil-print-debuginfo", llvm::cl::init(false),
                 llvm::cl::desc("Include debug info in SIL output"));
 
+llvm::cl::opt<bool>
+SILPrintSourceInfo("sil-print-sourceinfo", llvm::cl::init(false),
+                   llvm::cl::desc("Include source annotation in SIL output"));
+
 llvm::cl::opt<bool> SILPrintGenericSpecializationInfo(
     "sil-print-generic-specialization-info", llvm::cl::init(false),
     llvm::cl::desc("Include generic specialization"
@@ -618,7 +622,22 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     }
     *this << '\n';
 
+    const auto &SM = BB->getModule().getASTContext().SourceMgr;
+    Optional<SILLocation> PrevLoc;
     for (const SILInstruction &I : *BB) {
+      if (SILPrintSourceInfo) {
+        auto CurSourceLoc = I.getLoc().getSourceLoc();
+        if (CurSourceLoc.isValid()) {
+          if (!PrevLoc || SM.getLineNumber(CurSourceLoc) > SM.getLineNumber(PrevLoc->getSourceLoc())) {
+              auto Buffer = SM.findBufferContainingLoc(CurSourceLoc);
+              auto Line = SM.getLineNumber(CurSourceLoc);
+              auto LineLength = SM.getLineLength(Buffer, Line);
+              PrintState.OS << "  // " << SM.extractText({SM.getLocForLineCol(Buffer, Line, 0), LineLength.getValueOr(0)}) <<
+              "\tSourceLoc: " << SM.getDisplayNameForLoc(CurSourceLoc) << ":" << Line << "\n";
+              PrevLoc = I.getLoc();
+          }
+        }
+      }
       Ctx.printInstructionCallBack(&I);
       if (SILPrintGenericSpecializationInfo) {
         if (auto AI = ApplySite::isa(const_cast<SILInstruction *>(&I)))

lib/SILOptimizer/Analysis/EscapeAnalysis.cpp

@@ -122,6 +122,7 @@ SILValue EscapeAnalysis::getPointerBase(SILValue value) {
   case ValueKind::StructElementAddrInst:
   case ValueKind::StructExtractInst:
   case ValueKind::TupleElementAddrInst:
+  case ValueKind::BeginAccessInst:
   case ValueKind::UncheckedTakeEnumDataAddrInst:
   case ValueKind::UncheckedEnumDataInst:
   case ValueKind::MarkDependenceInst: