blob: 5b9580bdbe4b1ee6d81732fe5ca3257beebdec77 [file] [log] [blame]
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "tools/gn/command_format.h"
#include <stddef.h>
#include <sstream>
#include "base/command_line.h"
#include "base/files/file_util.h"
#include "base/json/json_writer.h"
#include "base/macros.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "tools/gn/commands.h"
#include "tools/gn/filesystem_utils.h"
#include "tools/gn/input_file.h"
#include "tools/gn/parser.h"
#include "tools/gn/scheduler.h"
#include "tools/gn/setup.h"
#include "tools/gn/source_file.h"
#include "tools/gn/tokenizer.h"
namespace commands {
const char kSwitchDryRun[] = "dry-run";
const char kSwitchDumpTree[] = "dump-tree";
const char kSwitchDumpTreeText[] = "text";
const char kSwitchDumpTreeJSON[] = "json";
const char kSwitchStdin[] = "stdin";
const char kFormat[] = "format";
const char kFormat_HelpShort[] = "format: Format .gn files.";
const char kFormat_Help[] =
R"(gn format [--dump-tree] (--stdin | <list of build_files...>)
Formats .gn file to a standard format.
The contents of some lists ('sources', 'deps', etc.) will be sorted to a
canonical order. To suppress this, you can add a comment of the form "#
NOSORT" immediately preceding the assignment. e.g.
# NOSORT
sources = [
"z.cc",
"a.cc",
]
Arguments
--dry-run
Does not change or output anything, but sets the process exit code based
on whether output would be different than what's on disk. This is useful
for presubmit/lint-type checks.
- Exit code 0: successful format, matches on disk.
- Exit code 1: general failure (parse error, etc.)
- Exit code 2: successful format, but differs from on disk.
--dump-tree[=( text | json )]
Dumps the parse tree to stdout and does not update the file or print
formatted output. If no format is specified, text format will be used.
--stdin
Read input from stdin and write to stdout rather than update a file
in-place.
Examples
gn format //some/BUILD.gn //some/other/BUILD.gn //and/another/BUILD.gn
gn format some\\BUILD.gn
gn format /abspath/some/BUILD.gn
gn format --stdin
)";
namespace {
const int kIndentSize = 2;
const int kMaximumWidth = 80;
const int kPenaltyLineBreak = 500;
const int kPenaltyHorizontalSeparation = 100;
const int kPenaltyExcess = 10000;
const int kPenaltyBrokenLineOnOneLiner = 5000;
enum Precedence {
kPrecedenceLowest,
kPrecedenceAssign,
kPrecedenceOr,
kPrecedenceAnd,
kPrecedenceCompare,
kPrecedenceAdd,
kPrecedenceUnary,
kPrecedenceSuffix,
};
int CountLines(const std::string& str) {
return static_cast<int>(base::SplitStringPiece(str, "\n",
base::KEEP_WHITESPACE,
base::SPLIT_WANT_ALL)
.size());
}
class Printer {
public:
Printer();
~Printer();
void Block(const ParseNode* file);
std::string String() const { return output_; }
private:
// Format a list of values using the given style.
enum SequenceStyle {
kSequenceStyleList,
kSequenceStyleBracedBlock,
kSequenceStyleBracedBlockAlreadyOpen,
};
struct Metrics {
Metrics() : first_length(-1), longest_length(-1), multiline(false) {}
int first_length;
int longest_length;
bool multiline;
};
// Add to output.
void Print(base::StringPiece str);
// Add the current margin (as spaces) to the output.
void PrintMargin();
void TrimAndPrintToken(const Token& token);
// End the current line, flushing end of line comments.
void Newline();
// Remove trailing spaces from the current line.
void Trim();
// Whether there's a blank separator line at the current position.
bool HaveBlankLine();
// Flag assignments to sources, deps, etc. to make their RHSs multiline.
void AnnotatePreferredMultilineAssignment(const BinaryOpNode* binop);
// Sort a list on the RHS if the LHS is 'sources', 'deps' or 'public_deps'.
// The 'sources' are sorted alphabetically while the 'deps' and 'public_deps'
// are sorted putting first the relative targets and then the global ones
// (both sorted alphabetically).
void SortIfSourcesOrDeps(const BinaryOpNode* binop);
// Sort contiguous import() function calls in the given ordered list of
// statements (the body of a block or scope).
template <class PARSENODE>
void SortImports(std::vector<std::unique_ptr<PARSENODE>>& statements);
// Heuristics to decide if there should be a blank line added between two
// items. For various "small" items, it doesn't look nice if there's too much
// vertical whitespace added.
bool ShouldAddBlankLineInBetween(const ParseNode* a, const ParseNode* b);
// Get the 0-based x position on the current line.
int CurrentColumn() const;
// Get the current line in the output;
int CurrentLine() const;
// Adds an opening ( if prec is less than the outers (to maintain evalution
// order for a subexpression). If an opening paren is emitted, *parenthesized
// will be set so it can be closed at the end of the expression.
void AddParen(int prec, int outer_prec, bool* parenthesized);
// Print the expression to the output buffer. Returns the type of element
// added to the output. The value of outer_prec gives the precedence of the
// operator outside this Expr. If that operator binds tighter than root's,
// Expr must introduce parentheses.
int Expr(const ParseNode* root, int outer_prec, const std::string& suffix);
// Generic penalties for exceeding maximum width, adding more lines, etc.
int AssessPenalty(const std::string& output);
// Tests if any lines exceed the maximum width.
bool ExceedsMaximumWidth(const std::string& output);
// Format a list of values using the given style.
// |end| holds any trailing comments to be printed just before the closing
// bracket.
template <class PARSENODE> // Just for const covariance.
void Sequence(SequenceStyle style,
const std::vector<std::unique_ptr<PARSENODE>>& list,
const ParseNode* end,
bool force_multiline);
// Returns the penalty.
int FunctionCall(const FunctionCallNode* func_call,
const std::string& suffix);
// Create a clone of this Printer in a similar state (other than the output,
// but including margins, etc.) to be used for dry run measurements.
void InitializeSub(Printer* sub);
template <class PARSENODE>
bool ListWillBeMultiline(const std::vector<std::unique_ptr<PARSENODE>>& list,
const ParseNode* end);
std::string output_; // Output buffer.
std::vector<Token> comments_; // Pending end-of-line comments.
int margin() const { return stack_.back().margin; }
int penalty_depth_;
int GetPenaltyForLineBreak() const {
return penalty_depth_ * kPenaltyLineBreak;
}
struct IndentState {
IndentState()
: margin(0),
continuation_requires_indent(false),
parent_is_boolean_or(false) {}
IndentState(int margin,
bool continuation_requires_indent,
bool parent_is_boolean_or)
: margin(margin),
continuation_requires_indent(continuation_requires_indent),
parent_is_boolean_or(parent_is_boolean_or) {}
// The left margin (number of spaces).
int margin;
bool continuation_requires_indent;
bool parent_is_boolean_or;
};
// Stack used to track
std::vector<IndentState> stack_;
// Gives the precedence for operators in a BinaryOpNode.
std::map<base::StringPiece, Precedence> precedence_;
DISALLOW_COPY_AND_ASSIGN(Printer);
};
Printer::Printer() : penalty_depth_(0) {
output_.reserve(100 << 10);
precedence_["="] = kPrecedenceAssign;
precedence_["+="] = kPrecedenceAssign;
precedence_["-="] = kPrecedenceAssign;
precedence_["||"] = kPrecedenceOr;
precedence_["&&"] = kPrecedenceAnd;
precedence_["<"] = kPrecedenceCompare;
precedence_[">"] = kPrecedenceCompare;
precedence_["=="] = kPrecedenceCompare;
precedence_["!="] = kPrecedenceCompare;
precedence_["<="] = kPrecedenceCompare;
precedence_[">="] = kPrecedenceCompare;
precedence_["+"] = kPrecedenceAdd;
precedence_["-"] = kPrecedenceAdd;
precedence_["!"] = kPrecedenceUnary;
stack_.push_back(IndentState());
}
Printer::~Printer() = default;
void Printer::Print(base::StringPiece str) {
str.AppendToString(&output_);
}
void Printer::PrintMargin() {
output_ += std::string(margin(), ' ');
}
void Printer::TrimAndPrintToken(const Token& token) {
std::string trimmed;
TrimWhitespaceASCII(token.value().as_string(), base::TRIM_ALL, &trimmed);
Print(trimmed);
}
void Printer::Newline() {
if (!comments_.empty()) {
Print(" ");
// Save the margin, and temporarily set it to where the first comment
// starts so that multiple suffix comments are vertically aligned. This
// will need to be fancier once we enforce 80 col.
stack_.push_back(IndentState(CurrentColumn(), false, false));
int i = 0;
for (const auto& c : comments_) {
if (i > 0) {
Trim();
Print("\n");
PrintMargin();
}
TrimAndPrintToken(c);
++i;
}
stack_.pop_back();
comments_.clear();
}
Trim();
Print("\n");
PrintMargin();
}
void Printer::Trim() {
size_t n = output_.size();
while (n > 0 && output_[n - 1] == ' ')
--n;
output_.resize(n);
}
bool Printer::HaveBlankLine() {
size_t n = output_.size();
while (n > 0 && output_[n - 1] == ' ')
--n;
return n > 2 && output_[n - 1] == '\n' && output_[n - 2] == '\n';
}
void Printer::AnnotatePreferredMultilineAssignment(const BinaryOpNode* binop) {
const IdentifierNode* ident = binop->left()->AsIdentifier();
const ListNode* list = binop->right()->AsList();
// This is somewhat arbitrary, but we include the 'deps'- and 'sources'-like
// things, but not flags things.
if (binop->op().value() == "=" && ident && list) {
const base::StringPiece lhs = ident->value().value();
if (lhs == "data" || lhs == "datadeps" || lhs == "data_deps" ||
lhs == "deps" || lhs == "inputs" || lhs == "outputs" ||
lhs == "public" || lhs == "public_deps" || lhs == "sources") {
const_cast<ListNode*>(list)->set_prefer_multiline(true);
}
}
}
void Printer::SortIfSourcesOrDeps(const BinaryOpNode* binop) {
if (const Comments* comments = binop->comments()) {
const std::vector<Token>& before = comments->before();
if (!before.empty() &&
(before.front().value().as_string() == "# NOSORT" ||
before.back().value().as_string() == "# NOSORT")) {
// Allow disabling of sort for specific actions that might be
// order-sensitive.
return;
}
}
const IdentifierNode* ident = binop->left()->AsIdentifier();
const ListNode* list = binop->right()->AsList();
if ((binop->op().value() == "=" || binop->op().value() == "+=" ||
binop->op().value() == "-=") &&
ident && list) {
const base::StringPiece lhs = ident->value().value();
if (lhs == "public" || lhs == "sources")
const_cast<ListNode*>(list)->SortAsStringsList();
else if (lhs == "deps" || lhs == "public_deps")
const_cast<ListNode*>(list)->SortAsDepsList();
}
}
template <class PARSENODE>
void Printer::SortImports(std::vector<std::unique_ptr<PARSENODE>>& statements) {
// Build a set of ranges by indices of FunctionCallNode's that are imports.
std::vector<std::vector<size_t>> import_statements;
auto is_import = [](const PARSENODE* p) {
const FunctionCallNode* func_call = p->AsFunctionCall();
return func_call && func_call->function().value() == "import";
};
std::vector<size_t> current_group;
for (size_t i = 0; i < statements.size(); ++i) {
if (is_import(statements[i].get())) {
if (i > 0 && (!is_import(statements[i - 1].get()) ||
ShouldAddBlankLineInBetween(statements[i - 1].get(),
statements[i].get()))) {
if (!current_group.empty()) {
import_statements.push_back(current_group);
current_group.clear();
}
}
current_group.push_back(i);
}
}
if (!current_group.empty())
import_statements.push_back(current_group);
struct CompareByImportFile {
bool operator()(const std::unique_ptr<PARSENODE>& a,
const std::unique_ptr<PARSENODE>& b) const {
const auto& a_args = a->AsFunctionCall()->args()->contents();
const auto& b_args = b->AsFunctionCall()->args()->contents();
base::StringPiece a_name;
base::StringPiece b_name;
if (!a_args.empty())
a_name = a_args[0]->AsLiteral()->value().value();
if (!b_args.empty())
b_name = b_args[0]->AsLiteral()->value().value();
auto is_absolute = [](base::StringPiece import) {
return import.size() >= 3 && import[0] == '"' && import[1] == '/' &&
import[2] == '/';
};
int a_is_rel = !is_absolute(a_name);
int b_is_rel = !is_absolute(b_name);
return std::tie(a_is_rel, a_name) < std::tie(b_is_rel, b_name);
}
};
int line_after_previous = -1;
for (const auto& group : import_statements) {
size_t begin = group[0];
size_t end = group.back() + 1;
// Save the original line number so that ranges can be re-assigned. They're
// contiguous because of the partitioning code above. Later formatting
// relies on correct line number to know whether to insert blank lines,
// which is why these need to be fixed up. Additionally, to handle multiple
// imports on one line, they're assigned sequential line numbers, and
// subsequent blocks will be gapped from them.
int start_line =
std::max(statements[begin]->GetRange().begin().line_number(),
line_after_previous + 1);
std::sort(statements.begin() + begin, statements.begin() + end,
CompareByImportFile());
const PARSENODE* prev = nullptr;
for (size_t i = begin; i < end; ++i) {
const PARSENODE* node = statements[i].get();
int line_number =
prev ? prev->GetRange().end().line_number() + 1 : start_line;
if (node->comments() && !node->comments()->before().empty())
line_number++;
const_cast<FunctionCallNode*>(node->AsFunctionCall())
->SetNewLocation(line_number);
prev = node;
line_after_previous = line_number + 1;
}
}
}
bool Printer::ShouldAddBlankLineInBetween(const ParseNode* a,
const ParseNode* b) {
LocationRange a_range = a->GetRange();
LocationRange b_range = b->GetRange();
// If they're already separated by 1 or more lines, then we want to keep a
// blank line.
return (b_range.begin().line_number() > a_range.end().line_number() + 1) ||
// Always put a blank line before a block comment.
b->AsBlockComment();
}
int Printer::CurrentColumn() const {
int n = 0;
while (n < static_cast<int>(output_.size()) &&
output_[output_.size() - 1 - n] != '\n') {
++n;
}
return n;
}
int Printer::CurrentLine() const {
int count = 1;
for (const char* p = output_.c_str(); (p = strchr(p, '\n')) != nullptr;) {
++count;
++p;
}
return count;
}
void Printer::Block(const ParseNode* root) {
const BlockNode* block = root->AsBlock();
if (block->comments()) {
for (const auto& c : block->comments()->before()) {
TrimAndPrintToken(c);
Newline();
}
}
SortImports(const_cast<std::vector<std::unique_ptr<ParseNode>>&>(
block->statements()));
size_t i = 0;
for (const auto& stmt : block->statements()) {
Expr(stmt.get(), kPrecedenceLowest, std::string());
Newline();
if (stmt->comments()) {
// Why are before() not printed here too? before() are handled inside
// Expr(), as are suffix() which are queued to the next Newline().
// However, because it's a general expression handler, it doesn't insert
// the newline itself, which only happens between block statements. So,
// the after are handled explicitly here.
for (const auto& c : stmt->comments()->after()) {
TrimAndPrintToken(c);
Newline();
}
}
if (i < block->statements().size() - 1 &&
(ShouldAddBlankLineInBetween(block->statements()[i].get(),
block->statements()[i + 1].get()))) {
Newline();
}
++i;
}
if (block->comments()) {
if (!block->statements().empty() &&
block->statements().back()->AsBlockComment()) {
// If the block ends in a comment, and there's a comment following it,
// then the two comments were originally separate, so keep them that way.
Newline();
}
for (const auto& c : block->comments()->after()) {
TrimAndPrintToken(c);
Newline();
}
}
}
int Printer::AssessPenalty(const std::string& output) {
int penalty = 0;
std::vector<std::string> lines = base::SplitString(
output, "\n", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
penalty += static_cast<int>(lines.size() - 1) * GetPenaltyForLineBreak();
for (const auto& line : lines) {
if (line.size() > kMaximumWidth)
penalty += static_cast<int>(line.size() - kMaximumWidth) * kPenaltyExcess;
}
return penalty;
}
bool Printer::ExceedsMaximumWidth(const std::string& output) {
for (const auto& line : base::SplitString(output, "\n", base::KEEP_WHITESPACE,
base::SPLIT_WANT_ALL)) {
if (line.size() > kMaximumWidth)
return true;
}
return false;
}
void Printer::AddParen(int prec, int outer_prec, bool* parenthesized) {
if (prec < outer_prec) {
Print("(");
*parenthesized = true;
}
}
int Printer::Expr(const ParseNode* root,
int outer_prec,
const std::string& suffix) {
std::string at_end = suffix;
int penalty = 0;
penalty_depth_++;
if (root->comments()) {
if (!root->comments()->before().empty()) {
Trim();
// If there's already other text on the line, start a new line.
if (CurrentColumn() > 0)
Print("\n");
// We're printing a line comment, so we need to be at the current margin.
PrintMargin();
for (const auto& c : root->comments()->before()) {
TrimAndPrintToken(c);
Newline();
}
}
}
bool parenthesized = false;
if (const AccessorNode* accessor = root->AsAccessor()) {
AddParen(kPrecedenceSuffix, outer_prec, &parenthesized);
Print(accessor->base().value());
if (accessor->member()) {
Print(".");
Expr(accessor->member(), kPrecedenceLowest, std::string());
} else {
CHECK(accessor->index());
Print("[");
Expr(accessor->index(), kPrecedenceLowest, "]");
}
} else if (const BinaryOpNode* binop = root->AsBinaryOp()) {
CHECK(precedence_.find(binop->op().value()) != precedence_.end());
AnnotatePreferredMultilineAssignment(binop);
SortIfSourcesOrDeps(binop);
Precedence prec = precedence_[binop->op().value()];
// Since binary operators format left-to-right, it is ok for the left side
// use the same operator without parentheses, so the left uses prec. For the
// same reason, the right side cannot reuse the same operator, or else "x +
// (y + z)" would format as "x + y + z" which means "(x + y) + z". So, treat
// the right expression as appearing one precedence level higher.
// However, because the source parens are not in the parse tree, as a
// special case for && and || we insert strictly-redundant-but-helpful-for-
// human-readers parentheses.
int prec_left = prec;
int prec_right = prec + 1;
if (binop->op().value() == "&&" && stack_.back().parent_is_boolean_or) {
Print("(");
parenthesized = true;
} else {
AddParen(prec_left, outer_prec, &parenthesized);
}
int start_line = CurrentLine();
int start_column = CurrentColumn();
bool is_assignment = binop->op().value() == "=" ||
binop->op().value() == "+=" ||
binop->op().value() == "-=";
int indent_column = start_column;
if (is_assignment) {
// Default to a double-indent for wrapped assignments.
indent_column = margin() + kIndentSize * 2;
// A special case for the long lists and scope assignments that are
// common in .gn files, don't indent them + 4, even though they're just
// continuations when they're simple lists like "x = [ a, b, c, ... ]" or
// scopes like "x = { a = 1 b = 2 }". Put back to "normal" indenting.
const ListNode* right_as_list = binop->right()->AsList();
if (right_as_list) {
if (right_as_list->prefer_multiline() ||
ListWillBeMultiline(right_as_list->contents(),
right_as_list->End()))
indent_column = start_column;
} else {
const BlockNode* right_as_block = binop->right()->AsBlock();
if (right_as_block)
indent_column = start_column;
}
}
if (stack_.back().continuation_requires_indent)
indent_column += kIndentSize * 2;
stack_.push_back(IndentState(indent_column,
stack_.back().continuation_requires_indent,
binop->op().value() == "||"));
Printer sub_left;
InitializeSub(&sub_left);
sub_left.Expr(binop->left(), prec_left,
std::string(" ") + binop->op().value().as_string());
bool left_is_multiline = CountLines(sub_left.String()) > 1;
// Avoid walking the whole left redundantly times (see timing of Format.046)
// so pull the output and comments from subprinter.
Print(sub_left.String().substr(start_column));
std::copy(sub_left.comments_.begin(), sub_left.comments_.end(),
std::back_inserter(comments_));
// Single line.
Printer sub1;
InitializeSub(&sub1);
sub1.Print(" ");
int penalty_current_line =
sub1.Expr(binop->right(), prec_right, std::string());
sub1.Print(suffix);
penalty_current_line += AssessPenalty(sub1.String());
if (!is_assignment && left_is_multiline) {
// In e.g. xxx + yyy, if xxx is already multiline, then we want a penalty
// for trying to continue as if this were one line.
penalty_current_line +=
(CountLines(sub1.String()) - 1) * kPenaltyBrokenLineOnOneLiner;
}
// Break after operator.
Printer sub2;
InitializeSub(&sub2);
sub2.Newline();
int penalty_next_line =
sub2.Expr(binop->right(), prec_right, std::string());
sub2.Print(suffix);
penalty_next_line += AssessPenalty(sub2.String());
// Force a list on the RHS that would normally be a single line into
// multiline.
bool tried_rhs_multiline = false;
Printer sub3;
InitializeSub(&sub3);
int penalty_multiline_rhs_list = std::numeric_limits<int>::max();
const ListNode* rhs_list = binop->right()->AsList();
if (is_assignment && rhs_list &&
!ListWillBeMultiline(rhs_list->contents(), rhs_list->End())) {
sub3.Print(" ");
sub3.stack_.push_back(IndentState(start_column, false, false));
sub3.Sequence(kSequenceStyleList, rhs_list->contents(), rhs_list->End(),
true);
sub3.stack_.pop_back();
penalty_multiline_rhs_list = AssessPenalty(sub3.String());
tried_rhs_multiline = true;
}
// If in all cases it was forced past 80col, then we don't break to avoid
// breaking after '=' in the case of:
// variable = "... very long string ..."
// as breaking and indenting doesn't make things much more readable, even
// though there's fewer characters past the maximum width.
bool exceeds_maximum_all_ways =
ExceedsMaximumWidth(sub1.String()) &&
ExceedsMaximumWidth(sub2.String()) &&
(!tried_rhs_multiline || ExceedsMaximumWidth(sub3.String()));
if (penalty_current_line < penalty_next_line || exceeds_maximum_all_ways) {
Print(" ");
Expr(binop->right(), prec_right, std::string());
} else if (tried_rhs_multiline &&
penalty_multiline_rhs_list < penalty_next_line) {
// Force a multiline list on the right.
Print(" ");
stack_.push_back(IndentState(start_column, false, false));
Sequence(kSequenceStyleList, rhs_list->contents(), rhs_list->End(), true);
stack_.pop_back();
} else {
// Otherwise, put first argument and op, and indent next.
Newline();
penalty += std::abs(CurrentColumn() - start_column) *
kPenaltyHorizontalSeparation;
Expr(binop->right(), prec_right, std::string());
}
stack_.pop_back();
penalty += (CurrentLine() - start_line) * GetPenaltyForLineBreak();
} else if (const BlockNode* block = root->AsBlock()) {
Sequence(kSequenceStyleBracedBlock, block->statements(), block->End(),
false);
} else if (const ConditionNode* condition = root->AsConditionNode()) {
Print("if (");
Expr(condition->condition(), kPrecedenceLowest, ") {");
Sequence(kSequenceStyleBracedBlockAlreadyOpen,
condition->if_true()->statements(), condition->if_true()->End(),
false);
if (condition->if_false()) {
Print(" else ");
// If it's a block it's a bare 'else', otherwise it's an 'else if'. See
// ConditionNode::Execute.
bool is_else_if = condition->if_false()->AsBlock() == nullptr;
if (is_else_if) {
Expr(condition->if_false(), kPrecedenceLowest, std::string());
} else {
Sequence(kSequenceStyleBracedBlock,
condition->if_false()->AsBlock()->statements(),
condition->if_false()->AsBlock()->End(), false);
}
}
} else if (const FunctionCallNode* func_call = root->AsFunctionCall()) {
penalty += FunctionCall(func_call, at_end);
at_end = "";
} else if (const IdentifierNode* identifier = root->AsIdentifier()) {
Print(identifier->value().value());
} else if (const ListNode* list = root->AsList()) {
bool force_multiline =
list->prefer_multiline() && !list->contents().empty();
Sequence(kSequenceStyleList, list->contents(), list->End(),
force_multiline);
} else if (const LiteralNode* literal = root->AsLiteral()) {
Print(literal->value().value());
} else if (const UnaryOpNode* unaryop = root->AsUnaryOp()) {
Print(unaryop->op().value());
Expr(unaryop->operand(), kPrecedenceUnary, std::string());
} else if (const BlockCommentNode* block_comment = root->AsBlockComment()) {
Print(block_comment->comment().value());
} else if (const EndNode* end = root->AsEnd()) {
Print(end->value().value());
} else {
CHECK(false) << "Unhandled case in Expr.";
}
if (parenthesized)
Print(")");
// Defer any end of line comment until we reach the newline.
if (root->comments() && !root->comments()->suffix().empty()) {
std::copy(root->comments()->suffix().begin(),
root->comments()->suffix().end(), std::back_inserter(comments_));
}
Print(at_end);
penalty_depth_--;
return penalty;
}
template <class PARSENODE>
void Printer::Sequence(SequenceStyle style,
const std::vector<std::unique_ptr<PARSENODE>>& list,
const ParseNode* end,
bool force_multiline) {
if (style == kSequenceStyleList) {
Print("[");
} else if (style == kSequenceStyleBracedBlock) {
Print("{");
} else if (style == kSequenceStyleBracedBlockAlreadyOpen) {
style = kSequenceStyleBracedBlock;
}
if (style == kSequenceStyleBracedBlock) {
force_multiline = true;
SortImports(const_cast<std::vector<std::unique_ptr<PARSENODE>>&>(list));
}
force_multiline |= ListWillBeMultiline(list, end);
if (list.size() == 0 && !force_multiline) {
// No elements, and not forcing newlines, print nothing.
} else if (list.size() == 1 && !force_multiline) {
Print(" ");
Expr(list[0].get(), kPrecedenceLowest, std::string());
CHECK(!list[0]->comments() || list[0]->comments()->after().empty());
Print(" ");
} else {
stack_.push_back(IndentState(margin() + kIndentSize,
style == kSequenceStyleList, false));
size_t i = 0;
for (const auto& x : list) {
Newline();
// If:
// - we're going to output some comments, and;
// - we haven't just started this multiline list, and;
// - there isn't already a blank line here;
// Then: insert one.
if (i != 0 && x->comments() && !x->comments()->before().empty() &&
!HaveBlankLine()) {
Newline();
}
bool body_of_list = i < list.size() - 1 || style == kSequenceStyleList;
bool want_comma =
body_of_list && (style == kSequenceStyleList && !x->AsBlockComment());
Expr(x.get(), kPrecedenceLowest, want_comma ? "," : std::string());
CHECK(!x->comments() || x->comments()->after().empty());
if (body_of_list) {
if (i < list.size() - 1 &&
ShouldAddBlankLineInBetween(list[i].get(), list[i + 1].get()))
Newline();
}
++i;
}
// Trailing comments.
if (end->comments() && !end->comments()->before().empty()) {
if (list.size() >= 2)
Newline();
for (const auto& c : end->comments()->before()) {
Newline();
TrimAndPrintToken(c);
}
}
stack_.pop_back();
Newline();
// Defer any end of line comment until we reach the newline.
if (end->comments() && !end->comments()->suffix().empty()) {
std::copy(end->comments()->suffix().begin(),
end->comments()->suffix().end(), std::back_inserter(comments_));
}
}
if (style == kSequenceStyleList)
Print("]");
else if (style == kSequenceStyleBracedBlock)
Print("}");
}
int Printer::FunctionCall(const FunctionCallNode* func_call,
const std::string& suffix) {
int start_line = CurrentLine();
int start_column = CurrentColumn();
Print(func_call->function().value());
Print("(");
bool have_block = func_call->block() != nullptr;
bool force_multiline = false;
const auto& list = func_call->args()->contents();
const ParseNode* end = func_call->args()->End();
if (end->comments() && !end->comments()->before().empty())
force_multiline = true;
// If there's before line comments, make sure we have a place to put them.
for (const auto& i : list) {
if (i->comments() && !i->comments()->before().empty())
force_multiline = true;
}
// Calculate the penalties for 3 possible layouts:
// 1. all on same line;
// 2. starting on same line, broken at each comma but paren aligned;
// 3. broken to next line + 4, broken at each comma.
std::string terminator = ")";
if (have_block)
terminator += " {";
terminator += suffix;
// Special case to make function calls of one arg taking a long list of
// boolean operators not indent.
bool continuation_requires_indent =
list.size() != 1 || !list[0]->AsBinaryOp();
// 1: Same line.
Printer sub1;
InitializeSub(&sub1);
sub1.stack_.push_back(
IndentState(CurrentColumn(), continuation_requires_indent, false));
int penalty_one_line = 0;
for (size_t i = 0; i < list.size(); ++i) {
penalty_one_line += sub1.Expr(list[i].get(), kPrecedenceLowest,
i < list.size() - 1 ? ", " : std::string());
}
sub1.Print(terminator);
penalty_one_line += AssessPenalty(sub1.String());
// This extra penalty prevents a short second argument from being squeezed in
// after a first argument that went multiline (and instead preferring a
// variant below).
penalty_one_line +=
(CountLines(sub1.String()) - 1) * kPenaltyBrokenLineOnOneLiner;
// 2: Starting on same line, broken at commas.
Printer sub2;
InitializeSub(&sub2);
sub2.stack_.push_back(
IndentState(CurrentColumn(), continuation_requires_indent, false));
int penalty_multiline_start_same_line = 0;
for (size_t i = 0; i < list.size(); ++i) {
penalty_multiline_start_same_line +=
sub2.Expr(list[i].get(), kPrecedenceLowest,
i < list.size() - 1 ? "," : std::string());
if (i < list.size() - 1) {
sub2.Newline();
}
}
sub2.Print(terminator);
penalty_multiline_start_same_line += AssessPenalty(sub2.String());
// 3: Starting on next line, broken at commas.
Printer sub3;
InitializeSub(&sub3);
sub3.stack_.push_back(IndentState(margin() + kIndentSize * 2,
continuation_requires_indent, false));
sub3.Newline();
int penalty_multiline_start_next_line = 0;
for (size_t i = 0; i < list.size(); ++i) {
if (i == 0) {
penalty_multiline_start_next_line +=
std::abs(sub3.CurrentColumn() - start_column) *
kPenaltyHorizontalSeparation;
}
penalty_multiline_start_next_line +=
sub3.Expr(list[i].get(), kPrecedenceLowest,
i < list.size() - 1 ? "," : std::string());
if (i < list.size() - 1) {
sub3.Newline();
}
}
sub3.Print(terminator);
penalty_multiline_start_next_line += AssessPenalty(sub3.String());
int penalty = penalty_multiline_start_next_line;
bool fits_on_current_line = false;
if (penalty_one_line < penalty_multiline_start_next_line ||
penalty_multiline_start_same_line < penalty_multiline_start_next_line) {
fits_on_current_line = true;
penalty = penalty_one_line;
if (penalty_multiline_start_same_line < penalty_one_line) {
penalty = penalty_multiline_start_same_line;
force_multiline = true;
}
} else {
force_multiline = true;
}
if (list.size() == 0 && !force_multiline) {
// No elements, and not forcing newlines, print nothing.
} else {
if (penalty_multiline_start_next_line < penalty_multiline_start_same_line) {
stack_.push_back(IndentState(margin() + kIndentSize * 2,
continuation_requires_indent, false));
Newline();
} else {
stack_.push_back(
IndentState(CurrentColumn(), continuation_requires_indent, false));
}
for (size_t i = 0; i < list.size(); ++i) {
const auto& x = list[i];
if (i > 0) {
if (fits_on_current_line && !force_multiline)
Print(" ");
else
Newline();
}
bool want_comma = i < list.size() - 1 && !x->AsBlockComment();
Expr(x.get(), kPrecedenceLowest, want_comma ? "," : std::string());
CHECK(!x->comments() || x->comments()->after().empty());
if (i < list.size() - 1) {
if (!want_comma)
Newline();
}
}
// Trailing comments.
if (end->comments() && !end->comments()->before().empty()) {
if (!list.empty())
Newline();
for (const auto& c : end->comments()->before()) {
Newline();
TrimAndPrintToken(c);
}
Newline();
}
stack_.pop_back();
}
// Defer any end of line comment until we reach the newline.
if (end->comments() && !end->comments()->suffix().empty()) {
std::copy(end->comments()->suffix().begin(),
end->comments()->suffix().end(), std::back_inserter(comments_));
}
Print(")");
Print(suffix);
if (have_block) {
Print(" ");
Sequence(kSequenceStyleBracedBlock, func_call->block()->statements(),
func_call->block()->End(), false);
}
return penalty + (CurrentLine() - start_line) * GetPenaltyForLineBreak();
}
void Printer::InitializeSub(Printer* sub) {
sub->stack_ = stack_;
sub->comments_ = comments_;
sub->penalty_depth_ = penalty_depth_;
sub->Print(std::string(CurrentColumn(), 'x'));
}
template <class PARSENODE>
bool Printer::ListWillBeMultiline(
const std::vector<std::unique_ptr<PARSENODE>>& list,
const ParseNode* end) {
if (list.size() > 1)
return true;
if (end && end->comments() && !end->comments()->before().empty())
return true;
// If there's before line comments, make sure we have a place to put them.
for (const auto& i : list) {
if (i->comments() && !i->comments()->before().empty())
return true;
}
// When a scope is used as a list entry, it's too complicated to go one a
// single line (the block will always be formatted multiline itself).
if (list.size() >= 1 && list[0]->AsBlock())
return true;
return false;
}
void DoFormat(const ParseNode* root, TreeDumpMode dump_tree,
std::string* output) {
if (dump_tree == TreeDumpMode::kPlainText) {
std::ostringstream os;
RenderToText(root->GetJSONNode(), 0, os);
fprintf(stderr, "%s", os.str().c_str());
} else if (dump_tree == TreeDumpMode::kJSON) {
std::string os;
base::JSONWriter::WriteWithOptions(root->GetJSONNode(),
base::JSONWriter::OPTIONS_PRETTY_PRINT, &os);
fprintf(stderr, "%s", os.c_str());
}
Printer pr;
pr.Block(root);
*output = pr.String();
}
std::string ReadStdin() {
static const int kBufferSize = 256;
char buffer[kBufferSize];
std::string result;
while (true) {
char* input = nullptr;
input = fgets(buffer, kBufferSize, stdin);
if (input == nullptr && feof(stdin))
return result;
int length = static_cast<int>(strlen(buffer));
if (length == 0)
return result;
else
result += std::string(buffer, length);
}
}
} // namespace
bool FormatFileToString(Setup* setup,
const SourceFile& file,
TreeDumpMode dump_tree,
std::string* output) {
Err err;
const ParseNode* parse_node =
setup->scheduler().input_file_manager()->SyncLoadFile(
LocationRange(), &setup->build_settings(), file, &err);
if (err.has_error()) {
err.PrintToStdout();
return false;
}
DoFormat(parse_node, dump_tree, output);
return true;
}
bool FormatStringToString(const std::string& input,
TreeDumpMode dump_tree,
std::string* output) {
SourceFile source_file;
InputFile file(source_file);
file.SetContents(input);
Err err;
// Tokenize.
std::vector<Token> tokens = Tokenizer::Tokenize(&file, &err);
if (err.has_error()) {
err.PrintToStdout();
return false;
}
// Parse.
std::unique_ptr<ParseNode> parse_node = Parser::Parse(tokens, &err);
if (err.has_error()) {
err.PrintToStdout();
return false;
}
DoFormat(parse_node.get(), dump_tree, output);
return true;
}
int RunFormat(const std::vector<std::string>& args) {
bool dry_run =
base::CommandLine::ForCurrentProcess()->HasSwitch(kSwitchDryRun);
TreeDumpMode dump_tree = TreeDumpMode::kInactive;
if (base::CommandLine::ForCurrentProcess()->HasSwitch(kSwitchDumpTree)) {
std::string tree_type = base::CommandLine::ForCurrentProcess()->
GetSwitchValueASCII(kSwitchDumpTree);
if (tree_type == kSwitchDumpTreeJSON) {
dump_tree = TreeDumpMode::kJSON;
} else if (tree_type.empty() || tree_type == kSwitchDumpTreeText) {
dump_tree = TreeDumpMode::kPlainText;
} else {
Err(Location(),
tree_type + " is an invalid value for --dump-tree. Specify "
"\"" + kSwitchDumpTreeText + "\" or \"" + kSwitchDumpTreeJSON +
"\".\n")
.PrintToStdout();
return 1;
}
}
bool from_stdin =
base::CommandLine::ForCurrentProcess()->HasSwitch(kSwitchStdin);
if (dry_run) {
// --dry-run only works with an actual file to compare to.
from_stdin = false;
}
if (from_stdin) {
if (args.size() != 0) {
Err(Location(), "Expecting no arguments when reading from stdin.\n")
.PrintToStdout();
return 1;
}
std::string input = ReadStdin();
std::string output;
if (!FormatStringToString(input, dump_tree, &output))
return 1;
printf("%s", output.c_str());
return 0;
}
if (args.size() == 0) {
Err(Location(), "Expecting one or more arguments, see `gn help format`.\n")
.PrintToStdout();
return 1;
}
Setup setup;
SourceDir source_dir =
SourceDirForCurrentDirectory(setup.build_settings().root_path());
// TODO(scottmg): Eventually, this list of files should be processed in
// parallel.
for (const auto& arg : args) {
Err err;
SourceFile file =
source_dir.ResolveRelativeFile(Value(nullptr, arg), &err);
if (err.has_error()) {
err.PrintToStdout();
return 1;
}
std::string output_string;
if (FormatFileToString(&setup, file, dump_tree, &output_string)) {
if (dump_tree == TreeDumpMode::kInactive) {
// Update the file in-place.
base::FilePath to_write = setup.build_settings().GetFullPath(file);
std::string original_contents;
if (!base::ReadFileToString(to_write, &original_contents)) {
Err(Location(), std::string("Couldn't read \"") +
FilePathToUTF8(to_write) +
std::string("\" for comparison."))
.PrintToStdout();
return 1;
}
if (dry_run)
return original_contents == output_string ? 0 : 2;
if (original_contents != output_string) {
if (base::WriteFile(to_write, output_string.data(),
static_cast<int>(output_string.size())) == -1) {
Err(Location(),
std::string("Failed to write formatted output back to \"") +
FilePathToUTF8(to_write) + std::string("\"."))
.PrintToStdout();
return 1;
}
printf("Wrote formatted to '%s'.\n", FilePathToUTF8(to_write).c_str());
}
}
}
}
return 0;
}
} // namespace commands