Columns and Bytes parent type

Author: tbaederr

clang/lib/Frontend/TextDiagnostic.cpp

@@ -47,63 +47,40 @@ static constexpr raw_ostream::Colors CommentColor = raw_ostream::YELLOW;
 static constexpr raw_ostream::Colors LiteralColor = raw_ostream::GREEN;
 static constexpr raw_ostream::Colors KeywordColor = raw_ostream::BLUE;
 
-struct Bytes {
+class ColumnsOrBytes {
+public:
   int V = 0;
-  Bytes() = default;
-  Bytes(int V) : V(V) {}
-  Bytes next() const { return Bytes(V + 1); }
-  Bytes prev() const { return Bytes(V - 1); }
+  ColumnsOrBytes(int V) : V(V) {}
   bool isValid() const { return V != -1; }
-  bool operator>(int V) { return this->V > V; }
-  bool operator>(Bytes O) { return V > O.V; }
-  bool operator<(int V) { return this->V < V; }
-  bool operator<(Bytes O) { return V < O.V; }
-  Bytes &operator++() {
-    ++V;
-    return *this;
-  }
-  Bytes &operator+=(Bytes B) {
-    V += B.V;
-    return *this;
-  }
-  Bytes &operator--() {
-    --V;
-    return *this;
-  }
-  bool operator<=(Bytes B) { return V <= B.V; }
-  Bytes operator-(int V) { return Bytes{this->V - V}; }
-  bool operator!=(int V) { return this->V != V; }
-};
 
-struct Columns {
-  int V = 0;
-  Columns() = default;
-  Columns(int V) : V(V) {}
-  bool isValid() const { return V != -1; }
-  Columns operator+(Columns B) { return Columns{V + B.V}; }
-  Columns &operator+=(Columns B) {
+  bool operator>(ColumnsOrBytes O) { return V > O.V; }
+  bool operator<(ColumnsOrBytes O) { return V < O.V; }
+  bool operator<=(ColumnsOrBytes B) { return V <= B.V; }
+  bool operator!=(ColumnsOrBytes C) { return C.V != V; }
+
+  ColumnsOrBytes &operator+=(ColumnsOrBytes B) {
     V += B.V;
     return *this;
   }
-  Columns &operator-=(Columns B) {
+  ColumnsOrBytes &operator-=(ColumnsOrBytes B) {
     V -= B.V;
     return *this;
   }
+};
+class Bytes final : public ColumnsOrBytes {
+public:
+  Bytes(int V) : ColumnsOrBytes(V) {}
+  Bytes next() const { return Bytes(V + 1); }
+  Bytes prev() const { return Bytes(V - 1); }
+  Bytes operator+(Bytes B) { return Bytes{V + B.V}; }
+};
+class Columns final : public ColumnsOrBytes {
+public:
+  Columns(int V) : ColumnsOrBytes(V) {}
+  Columns next() const { return Columns(V + 1); }
+  Columns prev() const { return Columns(V - 1); }
   Columns operator-(Columns B) { return Columns{V - B.V}; }
-  bool operator==(int V) { return this->V == V; }
-  bool operator<=(Columns B) { return V <= B.V; }
-  bool operator<(Columns B) { return V < B.V; }
-  bool operator>(Columns B) { return V > B.V; }
-  Columns &operator++() {
-    ++V;
-    return *this;
-  }
-  Columns &operator--() {
-    --V;
-    return *this;
-  }
-  bool operator!=(int V) { return this->V != V; }
-  bool operator!=(Columns C) { return C.V != V; }
+  Columns operator+(Columns B) { return Columns{V + B.V}; }
 };
 
 /// Add highlights to differences in template strings.
@@ -292,19 +269,19 @@ static void genColumnByteMapping(StringRef SourceLine, unsigned TabStop,
 
   ColumnsOut.resize(SourceLine.size() + 1, -1);
 
-  int NumColumns = 0;
+  Columns NumColumns = 0;
   size_t I = 0;
   while (I < SourceLine.size()) {
-    ColumnsOut[I] = Columns(NumColumns);
-    BytesOut.resize(NumColumns + 1, -1);
+    ColumnsOut[I] = NumColumns;
+    BytesOut.resize(NumColumns.V + 1, -1);
     BytesOut.back() = Bytes(I);
     auto [Str, Printable] =
         printableTextForNextCharacter(SourceLine, &I, TabStop);
-    NumColumns += llvm::sys::locale::columnWidth(Str);
+    NumColumns += Columns(llvm::sys::locale::columnWidth(Str));
   }
 
-  ColumnsOut.back() = Columns(NumColumns);
-  BytesOut.resize(NumColumns + 1, -1);
+  ColumnsOut.back() = NumColumns;
+  BytesOut.resize(NumColumns.V + 1, -1);
   BytesOut.back() = Bytes(I);
 }
 
@@ -351,14 +328,16 @@ struct SourceColumnMap {
   /// Map from a byte index to the next byte which starts a column.
   Bytes startOfNextColumn(Bytes N) const {
     assert(0 <= N.V && N.V < static_cast<int>(m_byteToColumn.size() - 1));
-    while (byteToColumn(++N) == -1) {}
+    while (!byteToColumn(N).isValid())
+      N = N.next();
     return N;
   }
 
   /// Map from a byte index to the previous byte which starts a column.
   Bytes startOfPreviousColumn(Bytes N) const {
     assert(0 < N.V && N.V < static_cast<int>(m_byteToColumn.size()));
-    while (byteToColumn(--N) == -1) {}
+    while (!byteToColumn(N).isValid())
+      N = N.prev();
     return N;
   }
 
@@ -395,11 +374,11 @@ static void selectInterestingSourceRegion(std::string &SourceLine,
   // Find the slice that we need to display the full caret line
   // correctly.
   Columns CaretStart = 0, CaretEnd = CaretLine.size();
-  for (; CaretStart != CaretEnd; ++CaretStart)
+  for (; CaretStart != CaretEnd; CaretStart = CaretStart.next())
     if (!isWhitespace(CaretLine[CaretStart.V]))
       break;
 
-  for (; CaretEnd != CaretStart; --CaretEnd)
+  for (; CaretEnd != CaretStart; CaretEnd = CaretEnd.prev())
     if (!isWhitespace(CaretLine[CaretEnd.V - 1]))
       break;
 
@@ -433,7 +412,7 @@ static void selectInterestingSourceRegion(std::string &SourceLine,
   // If it's not at a character's first column then advance it past the current
   //   character.
   while (CaretEnd < map.columns() && !map.columnToByte(CaretEnd).isValid())
-    ++CaretEnd;
+    CaretEnd = CaretEnd.next();
 
   assert(
       (CaretStart > map.columns() || map.columnToByte(CaretStart).isValid()) &&
@@ -1038,8 +1017,8 @@ static void highlightRange(const LineRange &R, const SourceColumnMap &Map,
 
   // Pick the last non-whitespace column.
   Bytes EndByte = Bytes{std::min(R.EndByte.V, Map.bytes().V)};
-  while (EndByte != 0 && (Map.getSourceLine()[EndByte.V - 1] == ' ' ||
-                          Map.getSourceLine()[EndByte.V - 1] == '\t'))
+  while (EndByte.V != 0 && (Map.getSourceLine()[EndByte.V - 1] == ' ' ||
+                            Map.getSourceLine()[EndByte.V - 1] == '\t'))
     EndByte = Map.startOfPreviousColumn(EndByte);
 
   // If the start/end passed each other, then we are trying to highlight a
@@ -1086,7 +1065,8 @@ static std::string buildFixItInsertionLine(FileID FID, unsigned LineNo,
       // "column" (printed width, platform-dependent) and what is a
       // "byte offset" (SourceManager "column").
       Bytes HintByteOffset =
-          Bytes(SM.getColumnNumber(HintLocInfo.first, HintLocInfo.second)) - 1;
+          Bytes(SM.getColumnNumber(HintLocInfo.first, HintLocInfo.second))
+              .prev();
 
       // The hint must start inside the source or right at the end
       assert(HintByteOffset < map.bytes().next());
@@ -1158,26 +1138,26 @@ prepareAndFilterRanges(const SmallVectorImpl<CharSourceRange> &Ranges,
 
     Bytes StartByte = SM.getExpansionColumnNumber(Begin);
     Bytes EndByte = SM.getExpansionColumnNumber(End);
-    assert(StartByte != 0 && "StartByte must be valid, 0 is invalid");
-    assert(EndByte != 0 && "EndByte must be valid, 0 is invalid");
+    assert(StartByte.V != 0 && "StartByte must be valid, 0 is invalid");
+    assert(EndByte.V != 0 && "EndByte must be valid, 0 is invalid");
     if (R.isTokenRange())
       EndByte += Bytes(Lexer::MeasureTokenLength(End, SM, LangOpts));
 
     // Only a single line.
     if (StartLineNo == EndLineNo) {
-      LineRanges.push_back({StartLineNo, StartByte - 1, EndByte - 1});
+      LineRanges.push_back({StartLineNo, StartByte.prev(), EndByte.prev()});
       continue;
     }
 
     // Start line.
-    LineRanges.push_back({StartLineNo, StartByte - 1, ~0u});
+    LineRanges.push_back({StartLineNo, StartByte.prev(), ~0u});
 
     // Middle lines.
     for (unsigned S = StartLineNo + 1; S != EndLineNo; ++S)
       LineRanges.push_back({S, 0, ~0u});
 
     // End line.
-    LineRanges.push_back({EndLineNo, 0, EndByte - 1});
+    LineRanges.push_back({EndLineNo, 0, EndByte.prev()});
   }
 
   return LineRanges;