[SIL] Introduce skipped coverage ranges

Introduce a skipped region kind, printed using
a `skipped` keyword.

Author: hamishknight

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/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/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/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)

test/SIL/Parser/coverage_maps.sil

@@ -18,6 +18,7 @@ sil_coverage_map "coverage_maps.sil" "someFunction" "coverage_maps.sil:someFunct
 // CHECK: 17:9 -> 17:17 : ((0 + 2) - 3)
 // CHECK: 17:9 -> 17:17 : ((0 + 2) - 3)
 // CHECK: 22:11 -> 139:2 : 1
+// CHECK: 54:1 -> 55:1 : skipped
 // CHECK: }
 sil_coverage_map "/some/other/file.sil" "someFunction" "/some/other/file.sil:someFunction" 0 {
   4:19 -> 31:1 : 0
@@ -26,4 +27,5 @@ sil_coverage_map "/some/other/file.sil" "someFunction" "/some/other/file.sil:som
   17:9 -> 17:17: ((0 + 2) - 3)
   17:9 -> 17:17: (0 + (2 - 3))
   22:11->139:2 : (zero + 1)
+  54:1 -> 55:1 : skipped
 }