Merge pull request #69782 from hamishknight/hash-it-out

Author: hamishknight

include/swift/AST/SourceFile.h

@@ -48,6 +48,39 @@ enum class RestrictedImportKind {
 /// Import that limits the access level of imported entities.
 using ImportAccessLevel = llvm::Optional<AttributedImport<ImportedModule>>;
 
+/// Stores range information for a \c #if block in a SourceFile.
+class IfConfigRangeInfo final {
+  /// The range of the entire \c #if block, including \c #else and \c #endif.
+  CharSourceRange WholeRange;
+
+  /// The range of the active selected body, if there is one. This does not
+  /// include the outer syntax of the \c #if. This may be invalid, which
+  /// indicates there is no active body.
+  CharSourceRange ActiveBodyRange;
+
+public:
+  IfConfigRangeInfo(CharSourceRange wholeRange, CharSourceRange activeBodyRange)
+      : WholeRange(wholeRange), ActiveBodyRange(activeBodyRange) {
+    assert(wholeRange.getByteLength() > 0 && "Range must be non-empty");
+    assert(activeBodyRange.isInvalid() || wholeRange.contains(activeBodyRange));
+  }
+
+  CharSourceRange getWholeRange() const { return WholeRange; }
+  SourceLoc getStartLoc() const { return WholeRange.getStart(); }
+
+  friend bool operator==(const IfConfigRangeInfo &lhs,
+                         const IfConfigRangeInfo &rhs) {
+    return lhs.WholeRange == rhs.WholeRange &&
+           lhs.ActiveBodyRange == rhs.ActiveBodyRange;
+  }
+
+  /// Retrieve the ranges produced by subtracting the active body range from
+  /// the whole range. This includes both inactive branches as well as the
+  /// other syntax of the \c #if.
+  SmallVector<CharSourceRange, 2>
+  getRangesWithoutActiveBody(const SourceManager &SM) const;
+};
+
 /// A file containing Swift source code.
 ///
 /// This is a .swift or .sil file (or a virtual file, such as the contents of
@@ -209,6 +242,19 @@ class SourceFile final : public FileUnit {
   ParserStatePtr DelayedParserState =
       ParserStatePtr(/*ptr*/ nullptr, /*deleter*/ nullptr);
 
+  struct IfConfigRangesData {
+    /// All the \c #if source ranges in this file.
+    std::vector<IfConfigRangeInfo> Ranges;
+
+    /// Whether the elemnts in \c Ranges are sorted in source order within
+    /// this file. We flip this to \c false any time a new range gets recorded,
+    /// and lazily do the sorting when doing a query.
+    bool IsSorted = false;
+  };
+
+  /// Stores all the \c #if source range info in this file.
+  mutable IfConfigRangesData IfConfigRanges;
+
   friend class HasImportsMatchingFlagRequest;
 
   /// Indicates which import options have valid caches. Storage for
@@ -448,6 +494,13 @@ class SourceFile final : public FileUnit {
      const_cast<SourceFile *>(this)->MissingImportedModules.insert(module);
   }
 
+  /// Record the source range info for a parsed \c #if block.
+  void recordIfConfigRangeInfo(IfConfigRangeInfo ranges);
+
+  /// Retrieve the source range infos for any \c #if blocks contained within a
+  /// given source range of this file.
+  ArrayRef<IfConfigRangeInfo> getIfConfigsWithin(SourceRange outer) const;
+
   void getMissingImportedModules(
          SmallVectorImpl<ImportedModule> &imports) const override;
 

include/swift/SIL/SILCoverageMap.h

@@ -41,17 +41,52 @@ namespace swift {
 class SILCoverageMap : public llvm::ilist_node<SILCoverageMap>,
                        public SILAllocated<SILCoverageMap> {
 public:
-  struct MappedRegion {
+  class MappedRegion {
+  public:
+    enum class Kind {
+      /// A code region, which represents a regular region of source code.
+      Code,
+
+      /// A skipped region, which represents a region that cannot have any
+      /// coverage associated with it. This is used for e.g the inactive body of
+      /// a \c #if.
+      Skipped
+    };
+
+    Kind RegionKind;
     unsigned StartLine;
     unsigned StartCol;
     unsigned EndLine;
     unsigned EndCol;
     llvm::coverage::Counter Counter;
 
-    MappedRegion(unsigned StartLine, unsigned StartCol, unsigned EndLine,
-                 unsigned EndCol, llvm::coverage::Counter Counter)
-        : StartLine(StartLine), StartCol(StartCol), EndLine(EndLine),
-          EndCol(EndCol), Counter(Counter) {}
+  private:
+    MappedRegion(Kind RegionKind, unsigned StartLine, unsigned StartCol,
+                 unsigned EndLine, unsigned EndCol,
+                 llvm::coverage::Counter Counter)
+        : RegionKind(RegionKind), StartLine(StartLine), StartCol(StartCol),
+          EndLine(EndLine), EndCol(EndCol), Counter(Counter) {}
+
+  public:
+    /// A code region, which represents a regular region of source code.
+    static MappedRegion code(unsigned StartLine, unsigned StartCol,
+                             unsigned EndLine, unsigned EndCol,
+                             llvm::coverage::Counter Counter) {
+      return MappedRegion(Kind::Code, StartLine, StartCol, EndLine, EndCol,
+                          Counter);
+    }
+
+    /// A skipped region, which represents a region that cannot have any
+    /// coverage associated with it. This is used for e.g the inactive body of
+    /// a \c #if.
+    static MappedRegion skipped(unsigned StartLine, unsigned StartCol,
+                                unsigned EndLine, unsigned EndCol) {
+      return MappedRegion(Kind::Skipped, StartLine, StartCol, EndLine, EndCol,
+                          llvm::coverage::Counter());
+    }
+
+    /// Retrieve the equivalent LLVM mapped region.
+    llvm::coverage::CounterMappingRegion getLLVMRegion(unsigned FileID) const;
   };
 
 private:

lib/AST/Module.cpp

@@ -3303,6 +3303,70 @@ SourceFile::getImportAccessLevel(const ModuleDecl *targetModule) const {
   return restrictiveImport;
 }
 
+SmallVector<CharSourceRange, 2>
+IfConfigRangeInfo::getRangesWithoutActiveBody(const SourceManager &SM) const {
+  SmallVector<CharSourceRange, 2> result;
+  if (ActiveBodyRange.isValid()) {
+    // Split the whole range by the active range.
+    result.emplace_back(SM, WholeRange.getStart(), ActiveBodyRange.getStart());
+    result.emplace_back(SM, ActiveBodyRange.getEnd(), WholeRange.getEnd());
+  } else {
+    // No active body, we just return the whole range.
+    result.push_back(WholeRange);
+  }
+  return result;
+}
+
+void SourceFile::recordIfConfigRangeInfo(IfConfigRangeInfo ranges) {
+  IfConfigRanges.Ranges.push_back(ranges);
+  IfConfigRanges.IsSorted = false;
+}
+
+ArrayRef<IfConfigRangeInfo>
+SourceFile::getIfConfigsWithin(SourceRange outer) const {
+  auto &SM = getASTContext().SourceMgr;
+  assert(SM.getRangeForBuffer(BufferID).contains(outer.Start) &&
+         "Range not within this file?");
+
+  if (!IfConfigRanges.IsSorted) {
+    // Sort the ranges if we need to.
+    llvm::sort(IfConfigRanges.Ranges, [&](IfConfigRangeInfo lhs,
+                                          IfConfigRangeInfo rhs) {
+      return SM.isBeforeInBuffer(lhs.getStartLoc(), rhs.getStartLoc());
+    });
+
+    // Be defensive and eliminate duplicates in case we've parsed twice.
+    auto newEnd = std::unique(
+        IfConfigRanges.Ranges.begin(), IfConfigRanges.Ranges.end(),
+        [&](const IfConfigRangeInfo &lhs, const IfConfigRangeInfo &rhs) {
+          if (lhs.getWholeRange() != rhs.getWholeRange())
+            return false;
+
+          assert(lhs == rhs && "Active ranges changed on a re-parse?");
+          return true;
+        });
+    IfConfigRanges.Ranges.erase(newEnd, IfConfigRanges.Ranges.end());
+    IfConfigRanges.IsSorted = true;
+  }
+
+  // First let's find the first #if that is after the outer start loc.
+  auto ranges = llvm::makeArrayRef(IfConfigRanges.Ranges);
+  auto lower = llvm::lower_bound(
+      ranges, outer.Start, [&](IfConfigRangeInfo range, SourceLoc loc) {
+        return SM.isBeforeInBuffer(range.getStartLoc(), loc);
+      });
+  if (lower == ranges.end() ||
+      SM.isBeforeInBuffer(outer.End, lower->getStartLoc())) {
+    return {};
+  }
+  // Next let's find the first #if that's after the outer end loc.
+  auto upper = llvm::upper_bound(
+      ranges, outer.End, [&](SourceLoc loc, IfConfigRangeInfo range) {
+        return SM.isBeforeInBuffer(loc, range.getStartLoc());
+      });
+  return llvm::makeArrayRef(lower, upper - lower);
+}
+
 void ModuleDecl::setPackageName(Identifier name) {
   Package = PackageUnit::create(name, *this, getASTContext());
 }

lib/IRGen/GenCoverage.cpp

@@ -143,11 +143,9 @@ void IRGenModule::emitCoverageMaps(ArrayRef<const SILCoverageMap *> Mappings) {
 
     std::vector<CounterMappingRegion> Regions;
     for (const auto &MR : M->getMappedRegions()) {
-      // The SubFileID here is 0, because it's an index into VirtualFileMapping,
+      // The FileID here is 0, because it's an index into VirtualFileMapping,
       // and we only ever have a single file associated for a function.
-      Regions.emplace_back(CounterMappingRegion::makeRegion(
-          MR.Counter, /*SubFileID*/ 0, MR.StartLine, MR.StartCol, MR.EndLine,
-          MR.EndCol));
+      Regions.push_back(MR.getLLVMRegion(/*FileID*/ 0));
     }
     // Append each function's regions into the encoded buffer.
     ArrayRef<unsigned> VirtualFileMapping(FileID);

lib/Parse/ParseIfConfig.cpp

@@ -785,6 +785,7 @@ Result Parser::parseIfConfigRaw(
                             bool isActive, IfConfigElementsRole role)>
       parseElements,
     llvm::function_ref<Result(SourceLoc endLoc, bool hadMissingEnd)> finish) {
+  auto startLoc = Tok.getLoc();
   assert(Tok.is(tok::pound_if));
 
   Parser::StructureMarkerRAII ParsingDecl(
@@ -824,6 +825,7 @@ Result Parser::parseIfConfigRaw(
 
   bool foundActive = false;
   bool isVersionCondition = false;
+  CharSourceRange activeBodyRange;
   while (1) {
     bool isElse = Tok.is(tok::pound_else);
     SourceLoc ClauseLoc = consumeToken();
@@ -881,6 +883,7 @@ Result Parser::parseIfConfigRaw(
     }
 
     // Parse elements
+    auto bodyStart = Lexer::getLocForEndOfToken(SourceMgr, PreviousLoc);
     llvm::SaveAndRestore<bool> S(InInactiveClauseEnvironment,
                                  InInactiveClauseEnvironment || !isActive);
     // Disable updating the interface hash inside inactive blocks.
@@ -899,6 +902,12 @@ Result Parser::parseIfConfigRaw(
           ClauseLoc, Condition, isActive, IfConfigElementsRole::Skipped);
     }
 
+    // Record the active body range for the SourceManager.
+    if (shouldEvaluate && isActive) {
+      assert(!activeBodyRange.isValid() && "Multiple active regions?");
+      activeBodyRange = CharSourceRange(SourceMgr, bodyStart, Tok.getLoc());
+    }
+
     if (Tok.isNot(tok::pound_elseif, tok::pound_else))
       break;
 
@@ -909,6 +918,12 @@ Result Parser::parseIfConfigRaw(
   SourceLoc EndLoc;
   bool HadMissingEnd = parseEndIfDirective(EndLoc);
 
+  // Record the #if ranges on the SourceManager.
+  if (!HadMissingEnd && shouldEvaluate) {
+    auto wholeRange = Lexer::getCharSourceRangeFromSourceRange(
+        SourceMgr, SourceRange(startLoc, EndLoc));
+    SF.recordIfConfigRangeInfo({wholeRange, activeBodyRange});
+  }
   return finish(EndLoc, HadMissingEnd);
 }
 

lib/SIL/IR/SILCoverageMap.cpp

@@ -22,6 +22,7 @@
 using namespace swift;
 
 using llvm::coverage::CounterExpression;
+using llvm::coverage::CounterMappingRegion;
 
 SILCoverageMap *
 SILCoverageMap::create(SILModule &M, SourceFile *ParentSourceFile,
@@ -56,6 +57,19 @@ SILCoverageMap::SILCoverageMap(SourceFile *ParentSourceFile, uint64_t Hash)
 
 SILCoverageMap::~SILCoverageMap() {}
 
+CounterMappingRegion
+SILCoverageMap::MappedRegion::getLLVMRegion(unsigned int FileID) const {
+  switch (RegionKind) {
+  case MappedRegion::Kind::Code:
+    return CounterMappingRegion::makeRegion(Counter, FileID, StartLine,
+                                            StartCol, EndLine, EndCol);
+  case MappedRegion::Kind::Skipped:
+    return CounterMappingRegion::makeSkipped(FileID, StartLine, StartCol,
+                                             EndLine, EndCol);
+  }
+  llvm_unreachable("Unhandled case in switch!");
+}
+
 namespace {
 struct Printer {
   const llvm::coverage::Counter &C;

lib/SIL/IR/SILPrinter.cpp

@@ -4168,7 +4168,14 @@ void SILCoverageMap::print(SILPrintContext &PrintCtx) const {
   for (auto &MR : getMappedRegions()) {
     OS << "  " << MR.StartLine << ":" << MR.StartCol << " -> " << MR.EndLine
        << ":" << MR.EndCol << " : ";
-    printCounter(OS, MR.Counter);
+    switch (MR.RegionKind) {
+    case MappedRegion::Kind::Code:
+      printCounter(OS, MR.Counter);
+      break;
+    case MappedRegion::Kind::Skipped:
+      OS << "skipped";
+      break;
+    }
     OS << "\n";
   }
   OS << "}\n\n";

lib/SIL/IR/SILProfiler.cpp

@@ -1066,19 +1066,41 @@ struct CoverageMapping : public ASTWalker {
     if (SourceRegions.empty())
       return nullptr;
 
+    using MappedRegion = SILCoverageMap::MappedRegion;
+
     llvm::coverage::CounterExpressionBuilder Builder;
-    std::vector<SILCoverageMap::MappedRegion> Regions;
+    std::vector<MappedRegion> Regions;
+    SourceRange OuterRange;
     for (const auto &Region : SourceRegions) {
       assert(Region.hasStartLoc() && "invalid region");
       assert(Region.hasEndLoc() && "incomplete region");
 
+      // Build up the outer range from the union of all coverage regions.
+      SourceRange Range(Region.getStartLoc(), Region.getEndLoc());
+      if (!OuterRange) {
+        OuterRange = Range;
+      } else {
+        OuterRange.widen(Range);
+      }
+
       auto Start = SM.getLineAndColumnInBuffer(Region.getStartLoc());
       auto End = SM.getLineAndColumnInBuffer(Region.getEndLoc());
       assert(Start.first <= End.first && "region start and end out of order");
 
       auto Counter = Region.getCounter(CounterMap);
-      Regions.emplace_back(Start.first, Start.second, End.first, End.second,
-                           Counter.expand(Builder, CounterIndices));
+      Regions.push_back(
+          MappedRegion::code(Start.first, Start.second, End.first, End.second,
+                             Counter.expand(Builder, CounterIndices)));
+    }
+    // Add any skipped regions present in the outer range.
+    for (auto IfConfig : SF->getIfConfigsWithin(OuterRange)) {
+      for (auto SkipRange : IfConfig.getRangesWithoutActiveBody(SM)) {
+        auto Start = SM.getLineAndColumnInBuffer(SkipRange.getStart());
+        auto End = SM.getLineAndColumnInBuffer(SkipRange.getEnd());
+        assert(Start.first <= End.first && "region start and end out of order");
+        Regions.push_back(MappedRegion::skipped(Start.first, Start.second,
+                                                End.first, End.second));
+      }
     }
     return SILCoverageMap::create(M, SF, Filename, Name, PGOFuncName, Hash,
                                   Regions, Builder.getExpressions());

lib/SIL/Parser/ParseSIL.cpp

@@ -8621,13 +8621,22 @@ bool SILParserState::parseSILCoverageMap(Parser &P) {
         break;
       }
 
-      auto Counter = State.parseSILCoverageExpr(Builder);
-      if (!Counter) {
-        BodyHasError = true;
-        break;
+      using MappedRegion = SILCoverageMap::MappedRegion;
+
+      if (P.Tok.isContextualKeyword("skipped")) {
+        P.consumeToken();
+        Regions.push_back(
+            MappedRegion::skipped(StartLine, StartCol, EndLine, EndCol));
+      } else {
+        auto Counter = State.parseSILCoverageExpr(Builder);
+        if (!Counter) {
+          BodyHasError = true;
+          break;
+        }
+        Regions.push_back(
+            MappedRegion::code(StartLine, StartCol, EndLine, EndCol, *Counter));
       }
 
-      Regions.emplace_back(StartLine, StartCol, EndLine, EndCol, *Counter);
     } while (P.Tok.isNot(tok::r_brace) && P.Tok.isNot(tok::eof));
   }
   if (BodyHasError)