Remove manual byte counting from Highlighter code.

[teemperor]

Summary

This removes the manual byte counting mechanism from the syntax highlighting
code. This is no longer necessary as the Stream class now has built-in support for
automatically counting the bytes that were written to it so far.

The advantage of automatic byte counting via Stream is that it is less error-prone
than the manual version and we need to write less boilerplate code.

[labath]

cool

include/lldb/Core/Highlighter.h

ColorStyle(llvm::StringRef prefix, llvm::StringRef suffix) {
       Set(prefix, suffix);
     }
 
     /// Applies this style to the given value.
     /// \param s
     ///     The stream to which the result should be appended.
     /// \param value
     ///     The value that we should place our strings around.
-    /// \return
-    ///     The number of bytes that have been written to the given stream.
-    std::size_t Apply(Stream &s, llvm::StringRef value) const;
+    void Apply(Stream &s, llvm::StringRef value) const;
 
     /// Sets the prefix and suffix strings.
     /// @param prefix
     /// @param suffix
     void Set(llvm::StringRef prefix, llvm::StringRef suffix);
   };
 
   /// Matches identifiers to variable or functions.
public:
   /// \param line
   ///     The user supplied line that needs to be highlighted.
   /// \param previous_lines
   ///     Any previous lines the user has written which we should only use
   ///     for getting the context of the Highlighting right.
   /// \param s
   ///     The stream to which the highlighted version of the user string should
   ///     be written.
-  /// \return
-  ///     The number of bytes that have been written to the stream.
-  virtual std::size_t Highlight(const HighlightStyle &options,
-                                llvm::StringRef line,
-                                llvm::StringRef previous_lines,
-                                Stream &s) const = 0;
+  virtual void Highlight(const HighlightStyle &options, llvm::StringRef line,
+                         llvm::StringRef previous_lines, Stream &s) const = 0;
 
   /// Utility method for calling Highlight without a stream.
   std::string Highlight(const HighlightStyle &options, llvm::StringRef line,
                         llvm::StringRef previous_lines = "") const;
 };
 
 /// A default highlighter that does nothing. Used as a fallback.
 class NoHighlighter : public Highlighter {
 public:
   llvm::StringRef GetName() const override { return "none"; }
 
-  std::size_t Highlight(const HighlightStyle &options, llvm::StringRef line,
-                        llvm::StringRef previous_lines,
-                        Stream &s) const override;
+  void Highlight(const HighlightStyle &options, llvm::StringRef line,
+                 llvm::StringRef previous_lines, Stream &s) const override;
 };
 
 /// Manages the available highlighters.
 class HighlighterManager {
   NoHighlighter m_no_highlighter;
 
 public:
   /// Queries all known highlighter for one that can highlight some source code.

source/Core/Highlighter.cpp

 #include "lldb/Core/Highlighter.h"
 
 #include "lldb/Target/Language.h"
 #include "lldb/Utility/AnsiTerminal.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb_private;
 
-std::size_t HighlightStyle::ColorStyle::Apply(Stream &s,
-                                              llvm::StringRef value) const {
+void HighlightStyle::ColorStyle::Apply(Stream &s, llvm::StringRef value) const {
   s << m_prefix << value << m_suffix;
-  // Calculate how many bytes we have written.
-  return m_prefix.size() + value.size() + m_suffix.size();
 }
 
 void HighlightStyle::ColorStyle::Set(llvm::StringRef prefix,
                                      llvm::StringRef suffix) {
   m_prefix = lldb_utility::ansi::FormatAnsiTerminalCodes(prefix);
   m_suffix = lldb_utility::ansi::FormatAnsiTerminalCodes(suffix);
 }
 
-std::size_t NoHighlighter::Highlight(const HighlightStyle &options,
-                                     llvm::StringRef line,
-                                     llvm::StringRef previous_lines,
-                                     Stream &s) const {
+void NoHighlighter::Highlight(const HighlightStyle &options,
+                              llvm::StringRef previous_lines, Stream &s) const {
   // We just forward the input to the output and do no highlighting.
   s << line;
-  return line.size();
 }
 
 static HighlightStyle::ColorStyle GetColor(const char *c) {
   return HighlightStyle::ColorStyle(c, "${ansi.normal}");
 }
 
 HighlightStyle HighlightStyle::MakeVimStyle() {
   HighlightStyle result;

source/Core/SourceManager.cpp

size_t SourceManager::File::DisplaySourceLines(uint32_t line, uint32_t column,
   // Nothing to write if there's no stream.
   if (!s)
     return 0;
 
   // Sanity check m_data_sp before proceeding.
   if (!m_data_sp)
     return 0;
 
+  size_t bytes_written = s->GetWrittenBytes();
+
   std::string previous_content;
 
   HighlightStyle style = HighlightStyle::MakeVimStyle();
   HighlighterManager mgr;
   std::string path = GetFileSpec().GetPath(/*denormalize*/ false);
   // FIXME: Find a way to get the definitive language this file was written in
   // and pass it to the highlighter.
   auto &highlighter =
       mgr.getHighlighterFor(lldb::LanguageType::eLanguageTypeUnknown, path);
 
   const uint32_t start_line =
       line <= context_before ? 1 : line - context_before;
   const uint32_t start_line_offset = GetLineOffset(start_line);
   if (start_line_offset != UINT32_MAX) {
     const uint32_t end_line = line + context_after;
     uint32_t end_line_offset = GetLineOffset(end_line + 1);
     if (end_line_offset == UINT32_MAX)
       end_line_offset = m_data_sp->GetByteSize();
 
     assert(start_line_offset <= end_line_offset);
-    size_t bytes_written = 0;
     if (start_line_offset < end_line_offset) {
       size_t count = end_line_offset - start_line_offset;
       const uint8_t *cstr = m_data_sp->GetBytes() + start_line_offset;
 
       auto ref = llvm::StringRef(reinterpret_cast<const char *>(cstr), count);
       bool displayed_line = false;
 
       auto debugger_sp = m_debugger_wp.lock();
       if (should_highlight_source(debugger_sp)) {
-        bytes_written +=
-            highlighter.Highlight(style, ref, previous_content, *s);
         displayed_line = true;
         // Add the new line to the previous lines.
         previous_content += ref.str();
       }
 
       if (!displayed_line && column && (column < count)) {
         if (should_show_stop_column_with_ansi(debugger_sp) && debugger_sp) {
           // Check if we have any ANSI codes with which to mark this column. If
           // not, no need to do this work.
           auto ansi_prefix_entry = debugger_sp->GetStopShowColumnAnsiPrefix();
           auto ansi_suffix_entry = debugger_sp->GetStopShowColumnAnsiSuffix();
 
           // We only bother breaking up the line to format the marked column if
           // there is any marking specified on both sides of the marked column.
           // In ANSI-terminal-sequence land, there must be a post if there is a
           // pre format, and vice versa.
           if (ansi_prefix_entry && ansi_suffix_entry) {
             // Mark the current column with the desired escape sequence for
             // formatting the column (e.g. underline, inverse, etc.)
 
             // First print the part before the column to mark.
-            bytes_written = s->Write(cstr, column - 1);
+            s->Write(cstr, column - 1);
 
             // Write the pre escape sequence.
             const SymbolContext *sc = nullptr;
             const ExecutionContext *exe_ctx = nullptr;
             const Address addr = LLDB_INVALID_ADDRESS;
             ValueObject *valobj = nullptr;
             const bool function_changed = false;
             const bool initial_function = false;
 
             FormatEntity::Format(*ansi_prefix_entry, *s, sc, exe_ctx, &addr,
                                  valobj, function_changed, initial_function);
 
-            // Write the marked column.
-            bytes_written += s->Write(cstr + column - 1, 1);
+            s->Write(cstr + column - 1, 1);
 
             // Write the post escape sequence.
             FormatEntity::Format(*ansi_suffix_entry, *s, sc, exe_ctx, &addr,
                                  valobj, function_changed, initial_function);
 
             // And finish up with the rest of the line.
-            bytes_written += s->Write(cstr + column, count - column);
+            s->Write(cstr + column, count - column);
 
             // Keep track of the fact that we just wrote the line.
             displayed_line = true;
           }
         }
       }
 
       // If we didn't end up displaying the line with ANSI codes for whatever
       // reason, display it now sans codes.
       if (!displayed_line)
-        bytes_written = s->PutCString(ref);
+        s->PutCString(ref);
 
       // Ensure we get an end of line character one way or another.
       if (!is_newline_char(ref.back()))
-        bytes_written += s->EOL();
+        s->EOL();
     }
-    return bytes_written;
   }
-  return 0;
+  return s->GetWrittenBytes() - bytes_written;
 }
 
 void SourceManager::File::FindLinesMatchingRegex(
     RegularExpression &regex, uint32_t start_line, uint32_t end_line,
     std::vector<uint32_t> &match_lines) {
   match_lines.clear();
 
   if (!LineIsValid(start_line) ||

source/Plugins/Language/ClangCommon/ClangHighlighter.h

 
 class ClangHighlighter : public Highlighter {
   llvm::StringSet<> keywords;
 
 public:
   ClangHighlighter();
   llvm::StringRef GetName() const override { return "clang"; }
 
-  std::size_t Highlight(const HighlightStyle &options, llvm::StringRef line,
-                        llvm::StringRef previous_lines,
-                        Stream &s) const override;
+  void Highlight(const HighlightStyle &options, llvm::StringRef line,
+                 llvm::StringRef previous_lines, Stream &s) const override;
 
   /// Returns true if the given string represents a keywords in any Clang
   /// supported language.
   bool isKeyword(llvm::StringRef token) const;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ClangHighlighter_h_

source/Plugins/Language/ClangCommon/ClangHighlighter.cpp

else
     case tok::equalequal:
       return options.operators;
     default:
       break;
     }
   return HighlightStyle::ColorStyle();
 }
 
-std::size_t ClangHighlighter::Highlight(const HighlightStyle &options,
-                                        llvm::StringRef line,
-                                        llvm::StringRef previous_lines,
-                                        Stream &result) const {
+void ClangHighlighter::Highlight(const HighlightStyle &options,
   using namespace clang;
 
-  std::size_t written_bytes = 0;
-
   FileSystemOptions file_opts;
   FileManager file_mgr(file_opts);
 
   unsigned line_number = previous_lines.count('\n') + 1U;
 
   // Let's build the actual source code Clang needs and setup some utility
   // objects.
   std::string full_source = previous_lines.str() + line.str();
while (!exit) {
     // If the token is just an empty string, we can skip all the work below.
     if (tok_str.empty())
       continue;
 
     // See how we are supposed to highlight this token.
     HighlightStyle::ColorStyle color =
         determineClangStyle(*this, token, tok_str, options, in_pp_directive);
 
-    written_bytes += color.Apply(result, tok_str);
+    color.Apply(result, tok_str);
   }
 
   // If we went over the whole file but couldn't find our own file, then
   // somehow our setup was wrong. When we're in release mode we just give the
   // user the normal line and pretend we don't know how to highlight it. In
   // debug mode we bail out with an assert as this should never happen.
   if (!found_user_line) {
     result << line;
-    written_bytes += line.size();
     assert(false && "We couldn't find the user line in the input file?");
   }
-
-  return written_bytes;
 }