tools/fidl/fidlc/lib/formatter.cc - fuchsia - Git at Google

 // Copyright 2018 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 // The implementation for the FormattingTreeVisitor that pretty-prints FIDL code.
 #include "fidl/formatter.h"

 #include <locale>
 #include <map>
 #include <regex>
 #include <set>
 #include <string>

 namespace fidl {
 namespace raw {

 // Rules:
 //   No more than one blank line in a row.
 //   Keep blank lines before and after comments.
 //   Will add newlines before top level declarations later.
 void FormattingTreeVisitor::Segment::RemoveExtraBlankLines(bool respects_trailing_blankline) {
   std::set<int> blank_line_indices;
   std::set<int> comment_line_indices;
   std::map<int, int> line_offsets;

   // First, find all of the blank lines and comment lines.
   int line_num = 0;
   line_offsets[line_num++] = 0;
   for (int i = 0; i < static_cast<int>(output_.size()); i++) {
     if (output_[i] == '\n' && i + 1 != static_cast<int>(output_.size())) {
       line_offsets[line_num] = i + 1;
       bool is_blank = true;
       bool is_comment = false;
       for (int j = i + 1; j < static_cast<int>(output_.size()) && output_[j] != '\n'; j++) {
         if (!utils::IsWhitespaceNoNewline(output_[j])) {
           is_blank = false;
         }
         if (utils::LineFromOffsetIsRegularComment(output_, j)) {
           is_comment = true;
         }
       }
       if (is_blank) {
         blank_line_indices.insert(line_num);
       }
       if (is_comment) {
         comment_line_indices.insert(line_num);
       }
       line_num++;
     }
   }

   int last_line_num = line_num - 1;

   // Next, get rid of any blank line that isn't next to a comment or,
   // if we are respecting trailing blank lines, right before the end.
   // Make an exception if the previous line is blank - i.e., coalesce
   // multiple blank lines.  Work backwards so we don't screw up line
   // numbers.
   auto unmodified_bli(blank_line_indices);
   for (auto i = unmodified_bli.rbegin(); i != unmodified_bli.rend(); ++i) {
     int line_num = *i;
     bool is_next_to_comment = comment_line_indices.count(line_num - 1) != 0 ||
                               comment_line_indices.count(line_num + 1) != 0;
     bool need_to_preserve_because_last =
         respects_trailing_blankline && line_num == last_line_num - 1;
     bool need_to_coalesce = blank_line_indices.count(line_num + 1) != 0;
     if ((!is_next_to_comment && !need_to_preserve_because_last) || need_to_coalesce) {
       int offset = line_offsets[line_num];
       size_t next_newline = output_.find_first_of("\n", offset);
       if (next_newline == std::string::npos) {
         next_newline = output_.size();
       }
       output_.erase(offset, next_newline - offset + 1);
       // This line doesn't exist anymore.  Erase it from the various
       // indices so that subsequent lines don't get confused about whether
       // they need to coalesce with a line that isn't there anymore.
       comment_line_indices.erase(line_num);
       blank_line_indices.erase(line_num);
     }
   }
 }

 // Assumptions: Leading WS has been stripped.
 // Rules:
 //  - newlines after ';', '{' (unless before a comment)
 //  - newlines before top-level decls (unless after a comment).
 void FormattingTreeVisitor::Segment::InsertRequiredNewlines(bool is_top_level) {
   // Insert lines after ';' and '{', if not already present
   for (int i = 0; i < static_cast<int>(output_.size()); i++) {
     MaybeWindPastComment(output_, i);
     char ch = output_[i];
     if (ch == ';' || ch == '{') {
       if (i == static_cast<int>(output_.size()) - 1) {
         output_.append("\n");
       } else {
         size_t j = output_.find_first_not_of(utils::kWhitespaceNoNewlineChars, i + 1);
         // Unless the next thing is a comment.
         if (j != std::string::npos && !utils::LineFromOffsetIsRegularComment(output_, j)) {
           // Make the next thing a newline.
           if (utils::IsWhitespaceNoNewline(output_[i + 1])) {
             output_[i + 1] = '\n';
           } else if (output_[i + 1] != '\n') {
             output_.insert(i + 1, "\n");
           }
         }
       }
     }
   }

   // Insert lines before top level decls.
   if (is_top_level) {
     // Right before the last word in this string, we need a blank line,
     // followed by some (possibly zero) number of comment lines.  So we
     // break the string into lines, and then work backwards.

     std::stringstream ss(output_);
     std::string tmp;
     std::vector<std::string> lines;

     while (std::getline(ss, tmp, '\n')) {
       lines.push_back(tmp);
     }
     std::string terminal = lines.back();
     lines.pop_back();
     if (lines.size() == 1) {
       lines[0].append("\n");
     } else {
       // From the end of the list of lines, find the first line
       // that isn't a comment, and insert a blank line (if it
       // isn't already blank).
       int i = static_cast<int>(lines.size()) - 1;
       while (i >= 0 && utils::FirstLineIsRegularComment(lines[i])) {
         i--;
       }

       if (!utils::FirstLineIsBlank(lines[i])) {
         lines.insert(lines.begin() + i + 1, "");
       }
     }
     output_ = "";
     for (auto line : lines) {
       output_ += line + "\n";
     }
     output_ += terminal;
   }
 }

 int FormattingTreeVisitor::Segment::EraseMultipleSpacesAt(int pos, int leave_this_many,
                                                           bool incl_newline) {
   std::function<bool(char)> is_ws;
   if (incl_newline) {
     is_ws = [](char ch) { return utils::IsWhitespace(ch); };
   } else {
     is_ws = [](char ch) { return utils::IsWhitespaceNoNewline(ch); };
   }
   if (!is_ws(output_[pos])) {
     return 0;
   }
   int length_of_spaces = 0;

   int start_pos = pos;
   int end_pos = pos;
   while (start_pos > 0 && is_ws(output_[start_pos - 1])) {
     start_pos--;
   }

   // int_size - 2 can be negative, and output_.size() is unsigned,
   // cast to make the comparison work.
   int int_size = static_cast<int>(output_.size());
   while (end_pos <= int_size - 2 && is_ws(output_[end_pos + 1])) {
     end_pos++;
   }

   length_of_spaces = end_pos - start_pos + 1;
   int num_deleted_spaces = std::max(length_of_spaces - leave_this_many, 0);
   output_.erase(start_pos, num_deleted_spaces);
   return num_deleted_spaces;
 }

 // Assumption: Trailing WS has been stripped, spaces have been changed to ' '
 // Rules:
 //  - No non-' ' or '\n' whitespace
 //  - One ws token before / after every ws-requiring character
 //  - No non-newline ws before / after characters that don't want it.
 //  - "->" operators are never at the end of the line.
 void FormattingTreeVisitor::Segment::RegularizeSpaces(bool& ws_required_next, bool& no_ws_next) {
   assert(!(ws_required_next && no_ws_next));

   bool last_char_required_ws = false;
   bool last_char_no_ws = false;

   if (ws_required_next && (output_.empty() || !utils::IsWhitespace(output_[0]))) {
     // The current string does not begin with the required whitespace, so insert it.
     output_.insert(0, " ");
     ws_required_next = false;
   } else if (no_ws_next) {
     EraseMultipleSpacesAt(0, 0);
   }

   for (int i = 0; i < static_cast<int>(output_.size()); i++) {
     // If it is a comment, jump to EOL.
     MaybeWindPastComment(output_, i);

     // If we see "->\n", change it to "\n->".
     const char arrow_nl[] = "->\n";
     if (output_.compare(i, strlen(arrow_nl), arrow_nl) == 0) {
       output_.replace(i, strlen(arrow_nl), "\n->");
       i -= EraseMultipleSpacesAt(i - 1, 0);
     }

     // Erase multiple spaces
     EraseMultipleSpacesAt(i);

     // Ensure whitespace around certain characters
     if (RequiresWSBeforeChar(output_[i])) {
       if (i == 0 || !utils::IsWhitespace(output_[i - 1])) {
         output_.insert(i, " ");
         i++;
       }
     }

     // This is a little weird.  '(' requires ws if it follows an
     // arrow, but not if it follows a method name.  Both of these
     // are in protocol method definitions, so this ends up being
     // slightly easier than having it positionally defined during
     // AST traversal.
     if (output_[i] == '(') {
       if (!last_char_required_ws && i > 0) {
         i -= EraseMultipleSpacesAt(i - 1, 0);
       }
     }

     // Ensure no whitespace around other characters
     if (NoSpacesBeforeChar(output_[i])) {
       if (i > 0) {
         i -= EraseMultipleSpacesAt(i - 1, 0, NoWSBeforeChar(output_[i]));
       }
     }

     // We don't want whitespace after these characters... unless there is a
     // comment after the WS.
     int j;
     for (j = i + 1;
          j < static_cast<int>(output_.size()) && utils::IsWhitespaceNoNewline(output_[j]); j++)
       ;
     if (NoWSAfterChar(output_[i]) && !utils::LineFromOffsetIsRegularComment(output_, j)) {
       EraseMultipleSpacesAt(i + 1, 0);
     }

     // The following clause is figuring out whether the next
     // iteration requires ws, so we need to keep it past anything
     // that uses that information in the loop.
     if (RequiresWSAfterChar(output_[i])) {
       if (i != static_cast<int>(output_.size()) - 1 && !utils::IsWhitespace(output_[i + 1])) {
         output_.insert(i + 1, " ");
         i++;
       }
       last_char_required_ws = true;
     } else {
       if (!utils::IsWhitespace(output_[i])) {
         last_char_required_ws = false;
       }
       last_char_no_ws = NoWSAfterChar(output_[i]);
     }
   }
   ws_required_next = last_char_required_ws;
   no_ws_next = last_char_no_ws;
 }

 // Rules are mostly obvious, but see TrackProtocolMethodAlignment below.
 // Precondition: By now, everything should have had its leading ws
 // stripped, and } characters are the first things on their own lines.
 void FormattingTreeVisitor::Segment::Indent(int& current_nesting) {
   for (int i = 0; i < static_cast<int>(output_.size()); i++) {
     if (output_[i] == '\n') {
       // Don't indent a blank line.
       if (output_[i + 1] == '\n') {
         continue;
       }
       // If this is an outdent line, do that.
       if (output_[i + 1] == '}') {
         current_nesting--;
       }
       int indent = current_nesting * kIndentSpaces;
       if (visitor_->newline_means_indent_more_) {
         if (visitor_->protocol_method_alignment_ &&
             visitor_->protocol_method_alignment_size_ > -1) {
           indent = visitor_->protocol_method_alignment_size_;
         } else {
           indent += kIndentSpaces;
         }
       }
       output_.insert(i + 1, indent, ' ');
     }

     int pos = i;
     // Skip comments at this point, because we don't want to
     // increase nesting based on a '{' character in a comment. :)
     MaybeWindPastComment(output_, pos);

     // 1 less than pos because i will be incremented on the next
     // iteration.  But that means it is a real character, so we need
     // to skip testing that character to see if it changes the
     // nesting level.
     if (pos != i) {
       i = pos - 1;
       continue;
     }

     if (output_[i] == '{') {
       current_nesting++;
     }
     if (output_[i] == ')') {
       visitor_->protocol_method_alignment_size_ = visitor_->offset_of_first_id_;
     }
     if (output_[i] == ']') {
       visitor_->protocol_method_alignment_size_ = visitor_->protocol_method_alignment_size_backup;
       visitor_->protocol_method_alignment_size_backup = -1;
     }
     if (output_[i] == ';') {
       visitor_->protocol_method_alignment_size_ = -1;
       visitor_->protocol_method_alignment_ = false;
       visitor_->newline_means_indent_more_ = false;
     }
   }
 }

 // The purpose of this method is to figure out what the indentation will be if
 // we encounter a newline.  The rule is :
 //  - If there isn't a parameter on the same line after the '(' character, +1
 //    indent past the beginning of the method name.
 //  - If there is a parameter on the same line after the '(' character,
 //    align at the same vertical column as that parameter.
 //  - If there is a parameter attribute, +1 indent past the beginning of '['
 void FormattingTreeVisitor::TrackProtocolMethodAlignment(const std::string& str) {
   static std::locale c_locale("C");
   if (!protocol_method_alignment_) {
     return;
   }

   for (int i = 0; i < static_cast<int>(str.size()); i++) {
     MaybeWindPastComment(str, i);

     char ch = str[i];
     if (ch == '\n') {
       if (has_encountered_param_list_start_ &&
           !is_param_list_first_param_on_same_line_.has_value()) {
         // The first parameter of the parameter list has not been encountered before a newline
         // character; thus, the first parameter is not on the same line.
         is_param_list_first_param_on_same_line_ = false;
       }
       distance_from_last_newline_ = 0;
     } else {
       distance_from_last_newline_++;
     }

     // This figures out if we are supposed to align to the '(' or the
     // method name.
     if (ch == '(') {
       has_encountered_param_list_start_ = true;
     }

     // Alignment for attributes.
     if (ch == '[') {
       if (has_encountered_param_list_start_ &&
           !is_param_list_first_param_on_same_line_.has_value()) {
         is_param_list_first_param_on_same_line_ = true;
         protocol_method_alignment_size_ = distance_from_last_newline_ - 1;
       }
       protocol_method_alignment_size_backup = protocol_method_alignment_size_;
       protocol_method_alignment_size_ = distance_from_last_newline_;
     }

     if (isalpha(ch, c_locale)) {
       if (protocol_method_alignment_size_ == -1) {
         // This should be the method identifier.
         offset_of_first_id_ = protocol_method_alignment_size_ =
             distance_from_last_newline_ + kIndentSpaces - 1;
       } else if (has_encountered_param_list_start_ &&
                  !is_param_list_first_param_on_same_line_.has_value()) {
         // This is the first element of the parameter list and its on the same line.
         is_param_list_first_param_on_same_line_ = true;
         protocol_method_alignment_size_ = distance_from_last_newline_ - 1;
       }
     }
   }
 }

 void FormattingTreeVisitor::OnFile(std::unique_ptr<fidl::raw::File> const& element) {
   // Eat ws at the beginning of the file.
   fidl::Token real_start = element->start_;
   std::string_view start_view = real_start.previous_end().data();
   const char* start_ptr = start_view.data();
   size_t initial_length = start_view.size();
   size_t offset = strspn(start_ptr, utils::kWhitespaceChars);
   std::string_view processed_file_start(start_ptr + offset, initial_length - offset);
   element->start_.set_previous_end(
       fidl::SourceSpan(processed_file_start, real_start.previous_end().source_file()));

   DeclarationOrderTreeVisitor::OnFile(element);
   // Remove EOF whitespace
   size_t final_size = formatted_output_.size();
   size_t last_char_index = final_size - 1;
   if (formatted_output_.at(last_char_index) != '\n' ||
       strchr(utils::kWhitespaceChars, formatted_output_.at(last_char_index - 1)) != nullptr) {
     while (strchr(utils::kWhitespaceChars, formatted_output_.at(last_char_index)) != nullptr) {
       last_char_index--;
     }
     formatted_output_ = formatted_output_.substr(0, last_char_index + 1);
     formatted_output_.append("\n");
   }
 }

 }  // namespace raw
 }  // namespace fidl
	// Copyright 2018 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	// The implementation for the FormattingTreeVisitor that pretty-prints FIDL code.
	#include "fidl/formatter.h"

	#include <locale>
	#include <map>
	#include <regex>
	#include <set>
	#include <string>

	namespace fidl {
	namespace raw {

	// Rules:
	// No more than one blank line in a row.
	// Keep blank lines before and after comments.
	// Will add newlines before top level declarations later.
	void FormattingTreeVisitor::Segment::RemoveExtraBlankLines(bool respects_trailing_blankline) {
	std::set<int> blank_line_indices;
	std::set<int> comment_line_indices;
	std::map<int, int> line_offsets;

	// First, find all of the blank lines and comment lines.
	int line_num = 0;
	line_offsets[line_num++] = 0;
	for (int i = 0; i < static_cast<int>(output_.size()); i++) {
	if (output_[i] == '\n' && i + 1 != static_cast<int>(output_.size())) {
	line_offsets[line_num] = i + 1;
	bool is_blank = true;
	bool is_comment = false;
	for (int j = i + 1; j < static_cast<int>(output_.size()) && output_[j] != '\n'; j++) {
	if (!utils::IsWhitespaceNoNewline(output_[j])) {
	is_blank = false;
	}
	if (utils::LineFromOffsetIsRegularComment(output_, j)) {
	is_comment = true;
	}
	}
	if (is_blank) {
	blank_line_indices.insert(line_num);
	}
	if (is_comment) {
	comment_line_indices.insert(line_num);
	}
	line_num++;
	}
	}

	int last_line_num = line_num - 1;

	// Next, get rid of any blank line that isn't next to a comment or,
	// if we are respecting trailing blank lines, right before the end.
	// Make an exception if the previous line is blank - i.e., coalesce
	// multiple blank lines. Work backwards so we don't screw up line
	// numbers.
	auto unmodified_bli(blank_line_indices);
	for (auto i = unmodified_bli.rbegin(); i != unmodified_bli.rend(); ++i) {
	int line_num = *i;
	bool is_next_to_comment = comment_line_indices.count(line_num - 1) != 0 \|\|
	comment_line_indices.count(line_num + 1) != 0;
	bool need_to_preserve_because_last =
	respects_trailing_blankline && line_num == last_line_num - 1;
	bool need_to_coalesce = blank_line_indices.count(line_num + 1) != 0;
	if ((!is_next_to_comment && !need_to_preserve_because_last) \|\| need_to_coalesce) {
	int offset = line_offsets[line_num];
	size_t next_newline = output_.find_first_of("\n", offset);
	if (next_newline == std::string::npos) {
	next_newline = output_.size();
	}
	output_.erase(offset, next_newline - offset + 1);
	// This line doesn't exist anymore. Erase it from the various
	// indices so that subsequent lines don't get confused about whether
	// they need to coalesce with a line that isn't there anymore.
	comment_line_indices.erase(line_num);
	blank_line_indices.erase(line_num);
	}
	}
	}

	// Assumptions: Leading WS has been stripped.
	// Rules:
	// - newlines after ';', '{' (unless before a comment)
	// - newlines before top-level decls (unless after a comment).
	void FormattingTreeVisitor::Segment::InsertRequiredNewlines(bool is_top_level) {
	// Insert lines after ';' and '{', if not already present
	for (int i = 0; i < static_cast<int>(output_.size()); i++) {
	MaybeWindPastComment(output_, i);
	char ch = output_[i];
	if (ch == ';' \|\| ch == '{') {
	if (i == static_cast<int>(output_.size()) - 1) {
	output_.append("\n");
	} else {
	size_t j = output_.find_first_not_of(utils::kWhitespaceNoNewlineChars, i + 1);
	// Unless the next thing is a comment.
	if (j != std::string::npos && !utils::LineFromOffsetIsRegularComment(output_, j)) {
	// Make the next thing a newline.
	if (utils::IsWhitespaceNoNewline(output_[i + 1])) {
	output_[i + 1] = '\n';
	} else if (output_[i + 1] != '\n') {
	output_.insert(i + 1, "\n");
	}
	}
	}
	}
	}

	// Insert lines before top level decls.
	if (is_top_level) {
	// Right before the last word in this string, we need a blank line,
	// followed by some (possibly zero) number of comment lines. So we
	// break the string into lines, and then work backwards.

	std::stringstream ss(output_);
	std::string tmp;
	std::vector<std::string> lines;

	while (std::getline(ss, tmp, '\n')) {
	lines.push_back(tmp);
	}
	std::string terminal = lines.back();
	lines.pop_back();
	if (lines.size() == 1) {
	lines[0].append("\n");
	} else {
	// From the end of the list of lines, find the first line
	// that isn't a comment, and insert a blank line (if it
	// isn't already blank).
	int i = static_cast<int>(lines.size()) - 1;
	while (i >= 0 && utils::FirstLineIsRegularComment(lines[i])) {
	i--;
	}

	if (!utils::FirstLineIsBlank(lines[i])) {
	lines.insert(lines.begin() + i + 1, "");
	}
	}
	output_ = "";
	for (auto line : lines) {
	output_ += line + "\n";
	}
	output_ += terminal;
	}
	}

	int FormattingTreeVisitor::Segment::EraseMultipleSpacesAt(int pos, int leave_this_many,
	bool incl_newline) {
	std::function<bool(char)> is_ws;
	if (incl_newline) {
	is_ws = [](char ch) { return utils::IsWhitespace(ch); };
	} else {
	is_ws = [](char ch) { return utils::IsWhitespaceNoNewline(ch); };
	}
	if (!is_ws(output_[pos])) {
	return 0;
	}
	int length_of_spaces = 0;

	int start_pos = pos;
	int end_pos = pos;
	while (start_pos > 0 && is_ws(output_[start_pos - 1])) {
	start_pos--;
	}

	// int_size - 2 can be negative, and output_.size() is unsigned,
	// cast to make the comparison work.
	int int_size = static_cast<int>(output_.size());
	while (end_pos <= int_size - 2 && is_ws(output_[end_pos + 1])) {
	end_pos++;
	}

	length_of_spaces = end_pos - start_pos + 1;
	int num_deleted_spaces = std::max(length_of_spaces - leave_this_many, 0);
	output_.erase(start_pos, num_deleted_spaces);
	return num_deleted_spaces;
	}

	// Assumption: Trailing WS has been stripped, spaces have been changed to ' '
	// Rules:
	// - No non-' ' or '\n' whitespace
	// - One ws token before / after every ws-requiring character
	// - No non-newline ws before / after characters that don't want it.
	// - "->" operators are never at the end of the line.
	void FormattingTreeVisitor::Segment::RegularizeSpaces(bool& ws_required_next, bool& no_ws_next) {
	assert(!(ws_required_next && no_ws_next));

	bool last_char_required_ws = false;
	bool last_char_no_ws = false;

	if (ws_required_next && (output_.empty() \|\| !utils::IsWhitespace(output_[0]))) {
	// The current string does not begin with the required whitespace, so insert it.
	output_.insert(0, " ");
	ws_required_next = false;
	} else if (no_ws_next) {
	EraseMultipleSpacesAt(0, 0);
	}

	for (int i = 0; i < static_cast<int>(output_.size()); i++) {
	// If it is a comment, jump to EOL.
	MaybeWindPastComment(output_, i);

	// If we see "->\n", change it to "\n->".
	const char arrow_nl[] = "->\n";
	if (output_.compare(i, strlen(arrow_nl), arrow_nl) == 0) {
	output_.replace(i, strlen(arrow_nl), "\n->");
	i -= EraseMultipleSpacesAt(i - 1, 0);
	}

	// Erase multiple spaces
	EraseMultipleSpacesAt(i);

	// Ensure whitespace around certain characters
	if (RequiresWSBeforeChar(output_[i])) {
	if (i == 0 \|\| !utils::IsWhitespace(output_[i - 1])) {
	output_.insert(i, " ");
	i++;
	}
	}

	// This is a little weird. '(' requires ws if it follows an
	// arrow, but not if it follows a method name. Both of these
	// are in protocol method definitions, so this ends up being
	// slightly easier than having it positionally defined during
	// AST traversal.
	if (output_[i] == '(') {
	if (!last_char_required_ws && i > 0) {
	i -= EraseMultipleSpacesAt(i - 1, 0);
	}
	}

	// Ensure no whitespace around other characters
	if (NoSpacesBeforeChar(output_[i])) {
	if (i > 0) {
	i -= EraseMultipleSpacesAt(i - 1, 0, NoWSBeforeChar(output_[i]));
	}
	}

	// We don't want whitespace after these characters... unless there is a
	// comment after the WS.
	int j;
	for (j = i + 1;
	j < static_cast<int>(output_.size()) && utils::IsWhitespaceNoNewline(output_[j]); j++)
	;
	if (NoWSAfterChar(output_[i]) && !utils::LineFromOffsetIsRegularComment(output_, j)) {
	EraseMultipleSpacesAt(i + 1, 0);
	}

	// The following clause is figuring out whether the next
	// iteration requires ws, so we need to keep it past anything
	// that uses that information in the loop.
	if (RequiresWSAfterChar(output_[i])) {
	if (i != static_cast<int>(output_.size()) - 1 && !utils::IsWhitespace(output_[i + 1])) {
	output_.insert(i + 1, " ");
	i++;
	}
	last_char_required_ws = true;
	} else {
	if (!utils::IsWhitespace(output_[i])) {
	last_char_required_ws = false;
	}
	last_char_no_ws = NoWSAfterChar(output_[i]);
	}
	}
	ws_required_next = last_char_required_ws;
	no_ws_next = last_char_no_ws;
	}

	// Rules are mostly obvious, but see TrackProtocolMethodAlignment below.
	// Precondition: By now, everything should have had its leading ws
	// stripped, and } characters are the first things on their own lines.
	void FormattingTreeVisitor::Segment::Indent(int& current_nesting) {
	for (int i = 0; i < static_cast<int>(output_.size()); i++) {
	if (output_[i] == '\n') {
	// Don't indent a blank line.
	if (output_[i + 1] == '\n') {
	continue;
	}
	// If this is an outdent line, do that.
	if (output_[i + 1] == '}') {
	current_nesting--;
	}
	int indent = current_nesting * kIndentSpaces;
	if (visitor_->newline_means_indent_more_) {
	if (visitor_->protocol_method_alignment_ &&
	visitor_->protocol_method_alignment_size_ > -1) {
	indent = visitor_->protocol_method_alignment_size_;
	} else {
	indent += kIndentSpaces;
	}
	}
	output_.insert(i + 1, indent, ' ');
	}

	int pos = i;
	// Skip comments at this point, because we don't want to
	// increase nesting based on a '{' character in a comment. :)
	MaybeWindPastComment(output_, pos);

	// 1 less than pos because i will be incremented on the next
	// iteration. But that means it is a real character, so we need
	// to skip testing that character to see if it changes the
	// nesting level.
	if (pos != i) {
	i = pos - 1;
	continue;
	}

	if (output_[i] == '{') {
	current_nesting++;
	}
	if (output_[i] == ')') {
	visitor_->protocol_method_alignment_size_ = visitor_->offset_of_first_id_;
	}
	if (output_[i] == ']') {
	visitor_->protocol_method_alignment_size_ = visitor_->protocol_method_alignment_size_backup;
	visitor_->protocol_method_alignment_size_backup = -1;
	}
	if (output_[i] == ';') {
	visitor_->protocol_method_alignment_size_ = -1;
	visitor_->protocol_method_alignment_ = false;
	visitor_->newline_means_indent_more_ = false;
	}
	}
	}

	// The purpose of this method is to figure out what the indentation will be if
	// we encounter a newline. The rule is :
	// - If there isn't a parameter on the same line after the '(' character, +1
	// indent past the beginning of the method name.
	// - If there is a parameter on the same line after the '(' character,
	// align at the same vertical column as that parameter.
	// - If there is a parameter attribute, +1 indent past the beginning of '['
	void FormattingTreeVisitor::TrackProtocolMethodAlignment(const std::string& str) {
	static std::locale c_locale("C");
	if (!protocol_method_alignment_) {
	return;
	}

	for (int i = 0; i < static_cast<int>(str.size()); i++) {
	MaybeWindPastComment(str, i);

	char ch = str[i];
	if (ch == '\n') {
	if (has_encountered_param_list_start_ &&
	!is_param_list_first_param_on_same_line_.has_value()) {
	// The first parameter of the parameter list has not been encountered before a newline
	// character; thus, the first parameter is not on the same line.
	is_param_list_first_param_on_same_line_ = false;
	}
	distance_from_last_newline_ = 0;
	} else {
	distance_from_last_newline_++;
	}

	// This figures out if we are supposed to align to the '(' or the
	// method name.
	if (ch == '(') {
	has_encountered_param_list_start_ = true;
	}

	// Alignment for attributes.
	if (ch == '[') {
	if (has_encountered_param_list_start_ &&
	!is_param_list_first_param_on_same_line_.has_value()) {
	is_param_list_first_param_on_same_line_ = true;
	protocol_method_alignment_size_ = distance_from_last_newline_ - 1;
	}
	protocol_method_alignment_size_backup = protocol_method_alignment_size_;
	protocol_method_alignment_size_ = distance_from_last_newline_;
	}

	if (isalpha(ch, c_locale)) {
	if (protocol_method_alignment_size_ == -1) {
	// This should be the method identifier.
	offset_of_first_id_ = protocol_method_alignment_size_ =
	distance_from_last_newline_ + kIndentSpaces - 1;
	} else if (has_encountered_param_list_start_ &&
	!is_param_list_first_param_on_same_line_.has_value()) {
	// This is the first element of the parameter list and its on the same line.
	is_param_list_first_param_on_same_line_ = true;
	protocol_method_alignment_size_ = distance_from_last_newline_ - 1;
	}
	}
	}
	}

	void FormattingTreeVisitor::OnFile(std::unique_ptr<fidl::raw::File> const& element) {
	// Eat ws at the beginning of the file.
	fidl::Token real_start = element->start_;
	std::string_view start_view = real_start.previous_end().data();
	const char* start_ptr = start_view.data();
	size_t initial_length = start_view.size();
	size_t offset = strspn(start_ptr, utils::kWhitespaceChars);
	std::string_view processed_file_start(start_ptr + offset, initial_length - offset);
	element->start_.set_previous_end(
	fidl::SourceSpan(processed_file_start, real_start.previous_end().source_file()));

	DeclarationOrderTreeVisitor::OnFile(element);
	// Remove EOF whitespace
	size_t final_size = formatted_output_.size();
	size_t last_char_index = final_size - 1;
	if (formatted_output_.at(last_char_index) != '\n' \|\|
	strchr(utils::kWhitespaceChars, formatted_output_.at(last_char_index - 1)) != nullptr) {
	while (strchr(utils::kWhitespaceChars, formatted_output_.at(last_char_index)) != nullptr) {
	last_char_index--;
	}
	formatted_output_ = formatted_output_.substr(0, last_char_index + 1);
	formatted_output_.append("\n");
	}
	}

	} // namespace raw
	} // namespace fidl