2012-12-04 02:12:45 +08:00
|
|
|
//===--- Format.cpp - Format C++ code -------------------------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
///
|
|
|
|
/// \file
|
|
|
|
/// \brief This file implements functions declared in Format.h. This will be
|
|
|
|
/// split into separate files as we go.
|
|
|
|
///
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2015-09-29 15:53:08 +08:00
|
|
|
#include "clang/Format/Format.h"
|
2016-04-25 23:09:22 +08:00
|
|
|
#include "AffectedRangeManager.h"
|
2013-08-16 19:20:30 +08:00
|
|
|
#include "ContinuationIndenter.h"
|
2016-05-20 19:24:24 +08:00
|
|
|
#include "FormatTokenLexer.h"
|
2017-02-27 21:28:36 +08:00
|
|
|
#include "NamespaceEndCommentsFixer.h"
|
2016-05-20 19:24:24 +08:00
|
|
|
#include "SortJavaScriptImports.h"
|
|
|
|
#include "TokenAnalyzer.h"
|
2013-01-30 05:01:14 +08:00
|
|
|
#include "TokenAnnotator.h"
|
2014-12-11 03:00:42 +08:00
|
|
|
#include "UnwrappedLineFormatter.h"
|
2012-12-04 17:13:33 +08:00
|
|
|
#include "UnwrappedLineParser.h"
|
2013-04-15 22:28:00 +08:00
|
|
|
#include "WhitespaceManager.h"
|
2013-05-16 18:40:07 +08:00
|
|
|
#include "clang/Basic/Diagnostic.h"
|
2014-05-11 00:31:55 +08:00
|
|
|
#include "clang/Basic/DiagnosticOptions.h"
|
2013-01-02 18:28:36 +08:00
|
|
|
#include "clang/Basic/SourceManager.h"
|
2016-04-14 22:47:37 +08:00
|
|
|
#include "clang/Basic/VirtualFileSystem.h"
|
2012-12-04 02:12:45 +08:00
|
|
|
#include "clang/Lex/Lexer.h"
|
2013-03-27 19:52:18 +08:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2013-02-13 18:46:36 +08:00
|
|
|
#include "llvm/Support/Allocator.h"
|
2013-01-16 22:55:28 +08:00
|
|
|
#include "llvm/Support/Debug.h"
|
2013-09-30 21:31:48 +08:00
|
|
|
#include "llvm/Support/Path.h"
|
2015-07-04 01:25:16 +08:00
|
|
|
#include "llvm/Support/Regex.h"
|
2014-01-07 19:51:46 +08:00
|
|
|
#include "llvm/Support/YAMLTraits.h"
|
2016-06-01 23:19:53 +08:00
|
|
|
#include <algorithm>
|
2016-04-25 23:09:22 +08:00
|
|
|
#include <memory>
|
2012-12-04 21:02:32 +08:00
|
|
|
#include <string>
|
|
|
|
|
2014-04-22 11:17:02 +08:00
|
|
|
#define DEBUG_TYPE "format-formatter"
|
|
|
|
|
2013-12-10 18:30:34 +08:00
|
|
|
using clang::format::FormatStyle;
|
|
|
|
|
2014-04-01 20:55:11 +08:00
|
|
|
LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(std::string)
|
2015-10-06 19:54:18 +08:00
|
|
|
LLVM_YAML_IS_SEQUENCE_VECTOR(clang::format::FormatStyle::IncludeCategory)
|
2014-04-01 20:55:11 +08:00
|
|
|
|
2013-05-07 23:32:14 +08:00
|
|
|
namespace llvm {
|
|
|
|
namespace yaml {
|
2013-12-10 18:30:34 +08:00
|
|
|
template <> struct ScalarEnumerationTraits<FormatStyle::LanguageKind> {
|
|
|
|
static void enumeration(IO &IO, FormatStyle::LanguageKind &Value) {
|
|
|
|
IO.enumCase(Value, "Cpp", FormatStyle::LK_Cpp);
|
2014-09-15 19:21:46 +08:00
|
|
|
IO.enumCase(Value, "Java", FormatStyle::LK_Java);
|
2013-12-10 18:30:34 +08:00
|
|
|
IO.enumCase(Value, "JavaScript", FormatStyle::LK_JavaScript);
|
2016-12-12 20:42:29 +08:00
|
|
|
IO.enumCase(Value, "ObjC", FormatStyle::LK_ObjC);
|
2014-01-19 17:04:08 +08:00
|
|
|
IO.enumCase(Value, "Proto", FormatStyle::LK_Proto);
|
2015-12-25 16:53:31 +08:00
|
|
|
IO.enumCase(Value, "TableGen", FormatStyle::LK_TableGen);
|
2013-11-29 23:19:43 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2013-12-10 18:30:34 +08:00
|
|
|
template <> struct ScalarEnumerationTraits<FormatStyle::LanguageStandard> {
|
|
|
|
static void enumeration(IO &IO, FormatStyle::LanguageStandard &Value) {
|
|
|
|
IO.enumCase(Value, "Cpp03", FormatStyle::LS_Cpp03);
|
|
|
|
IO.enumCase(Value, "C++03", FormatStyle::LS_Cpp03);
|
|
|
|
IO.enumCase(Value, "Cpp11", FormatStyle::LS_Cpp11);
|
|
|
|
IO.enumCase(Value, "C++11", FormatStyle::LS_Cpp11);
|
|
|
|
IO.enumCase(Value, "Auto", FormatStyle::LS_Auto);
|
2013-05-13 20:51:40 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2013-12-10 18:30:34 +08:00
|
|
|
template <> struct ScalarEnumerationTraits<FormatStyle::UseTabStyle> {
|
|
|
|
static void enumeration(IO &IO, FormatStyle::UseTabStyle &Value) {
|
|
|
|
IO.enumCase(Value, "Never", FormatStyle::UT_Never);
|
|
|
|
IO.enumCase(Value, "false", FormatStyle::UT_Never);
|
|
|
|
IO.enumCase(Value, "Always", FormatStyle::UT_Always);
|
|
|
|
IO.enumCase(Value, "true", FormatStyle::UT_Always);
|
|
|
|
IO.enumCase(Value, "ForIndentation", FormatStyle::UT_ForIndentation);
|
2016-04-14 22:52:26 +08:00
|
|
|
IO.enumCase(Value, "ForContinuationAndIndentation",
|
|
|
|
FormatStyle::UT_ForContinuationAndIndentation);
|
2013-09-28 00:14:22 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2016-03-03 06:44:03 +08:00
|
|
|
template <> struct ScalarEnumerationTraits<FormatStyle::JavaScriptQuoteStyle> {
|
|
|
|
static void enumeration(IO &IO, FormatStyle::JavaScriptQuoteStyle &Value) {
|
|
|
|
IO.enumCase(Value, "Leave", FormatStyle::JSQS_Leave);
|
|
|
|
IO.enumCase(Value, "Single", FormatStyle::JSQS_Single);
|
|
|
|
IO.enumCase(Value, "Double", FormatStyle::JSQS_Double);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2014-04-08 20:46:38 +08:00
|
|
|
template <> struct ScalarEnumerationTraits<FormatStyle::ShortFunctionStyle> {
|
|
|
|
static void enumeration(IO &IO, FormatStyle::ShortFunctionStyle &Value) {
|
|
|
|
IO.enumCase(Value, "None", FormatStyle::SFS_None);
|
|
|
|
IO.enumCase(Value, "false", FormatStyle::SFS_None);
|
|
|
|
IO.enumCase(Value, "All", FormatStyle::SFS_All);
|
|
|
|
IO.enumCase(Value, "true", FormatStyle::SFS_All);
|
|
|
|
IO.enumCase(Value, "Inline", FormatStyle::SFS_Inline);
|
2014-11-26 18:43:58 +08:00
|
|
|
IO.enumCase(Value, "Empty", FormatStyle::SFS_Empty);
|
2014-04-08 20:46:38 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2014-09-15 19:11:00 +08:00
|
|
|
template <> struct ScalarEnumerationTraits<FormatStyle::BinaryOperatorStyle> {
|
|
|
|
static void enumeration(IO &IO, FormatStyle::BinaryOperatorStyle &Value) {
|
|
|
|
IO.enumCase(Value, "All", FormatStyle::BOS_All);
|
|
|
|
IO.enumCase(Value, "true", FormatStyle::BOS_All);
|
|
|
|
IO.enumCase(Value, "None", FormatStyle::BOS_None);
|
|
|
|
IO.enumCase(Value, "false", FormatStyle::BOS_None);
|
|
|
|
IO.enumCase(Value, "NonAssignment", FormatStyle::BOS_NonAssignment);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2013-12-10 18:30:34 +08:00
|
|
|
template <> struct ScalarEnumerationTraits<FormatStyle::BraceBreakingStyle> {
|
|
|
|
static void enumeration(IO &IO, FormatStyle::BraceBreakingStyle &Value) {
|
|
|
|
IO.enumCase(Value, "Attach", FormatStyle::BS_Attach);
|
|
|
|
IO.enumCase(Value, "Linux", FormatStyle::BS_Linux);
|
2015-07-12 11:13:54 +08:00
|
|
|
IO.enumCase(Value, "Mozilla", FormatStyle::BS_Mozilla);
|
2013-12-10 18:30:34 +08:00
|
|
|
IO.enumCase(Value, "Stroustrup", FormatStyle::BS_Stroustrup);
|
|
|
|
IO.enumCase(Value, "Allman", FormatStyle::BS_Allman);
|
2013-12-12 17:49:52 +08:00
|
|
|
IO.enumCase(Value, "GNU", FormatStyle::BS_GNU);
|
2015-08-10 21:43:19 +08:00
|
|
|
IO.enumCase(Value, "WebKit", FormatStyle::BS_WebKit);
|
2015-09-29 22:57:55 +08:00
|
|
|
IO.enumCase(Value, "Custom", FormatStyle::BS_Custom);
|
2013-05-07 23:32:14 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-12-19 06:20:15 +08:00
|
|
|
template <>
|
|
|
|
struct ScalarEnumerationTraits<FormatStyle::ReturnTypeBreakingStyle> {
|
|
|
|
static void enumeration(IO &IO, FormatStyle::ReturnTypeBreakingStyle &Value) {
|
|
|
|
IO.enumCase(Value, "None", FormatStyle::RTBS_None);
|
|
|
|
IO.enumCase(Value, "All", FormatStyle::RTBS_All);
|
|
|
|
IO.enumCase(Value, "TopLevel", FormatStyle::RTBS_TopLevel);
|
|
|
|
IO.enumCase(Value, "TopLevelDefinitions",
|
|
|
|
FormatStyle::RTBS_TopLevelDefinitions);
|
|
|
|
IO.enumCase(Value, "AllDefinitions", FormatStyle::RTBS_AllDefinitions);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-09-29 22:57:55 +08:00
|
|
|
template <>
|
|
|
|
struct ScalarEnumerationTraits<FormatStyle::DefinitionReturnTypeBreakingStyle> {
|
|
|
|
static void
|
|
|
|
enumeration(IO &IO, FormatStyle::DefinitionReturnTypeBreakingStyle &Value) {
|
2015-06-29 23:30:42 +08:00
|
|
|
IO.enumCase(Value, "None", FormatStyle::DRTBS_None);
|
|
|
|
IO.enumCase(Value, "All", FormatStyle::DRTBS_All);
|
|
|
|
IO.enumCase(Value, "TopLevel", FormatStyle::DRTBS_TopLevel);
|
|
|
|
|
|
|
|
// For backward compatibility.
|
|
|
|
IO.enumCase(Value, "false", FormatStyle::DRTBS_None);
|
|
|
|
IO.enumCase(Value, "true", FormatStyle::DRTBS_All);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2013-08-01 07:16:02 +08:00
|
|
|
template <>
|
2013-12-10 18:30:34 +08:00
|
|
|
struct ScalarEnumerationTraits<FormatStyle::NamespaceIndentationKind> {
|
|
|
|
static void enumeration(IO &IO,
|
|
|
|
FormatStyle::NamespaceIndentationKind &Value) {
|
|
|
|
IO.enumCase(Value, "None", FormatStyle::NI_None);
|
|
|
|
IO.enumCase(Value, "Inner", FormatStyle::NI_Inner);
|
|
|
|
IO.enumCase(Value, "All", FormatStyle::NI_All);
|
2013-08-01 07:16:02 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-10-27 20:38:37 +08:00
|
|
|
template <> struct ScalarEnumerationTraits<FormatStyle::BracketAlignmentStyle> {
|
|
|
|
static void enumeration(IO &IO, FormatStyle::BracketAlignmentStyle &Value) {
|
|
|
|
IO.enumCase(Value, "Align", FormatStyle::BAS_Align);
|
|
|
|
IO.enumCase(Value, "DontAlign", FormatStyle::BAS_DontAlign);
|
|
|
|
IO.enumCase(Value, "AlwaysBreak", FormatStyle::BAS_AlwaysBreak);
|
|
|
|
|
|
|
|
// For backward compatibility.
|
|
|
|
IO.enumCase(Value, "true", FormatStyle::BAS_Align);
|
|
|
|
IO.enumCase(Value, "false", FormatStyle::BAS_DontAlign);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-05-08 23:08:00 +08:00
|
|
|
template <> struct ScalarEnumerationTraits<FormatStyle::EscapedNewlineAlignmentStyle> {
|
|
|
|
static void enumeration(IO &IO, FormatStyle::EscapedNewlineAlignmentStyle &Value) {
|
|
|
|
IO.enumCase(Value, "DontAlign", FormatStyle::ENAS_DontAlign);
|
|
|
|
IO.enumCase(Value, "Left", FormatStyle::ENAS_Left);
|
|
|
|
IO.enumCase(Value, "Right", FormatStyle::ENAS_Right);
|
|
|
|
|
|
|
|
// For backward compatibility.
|
|
|
|
IO.enumCase(Value, "true", FormatStyle::ENAS_Left);
|
|
|
|
IO.enumCase(Value, "false", FormatStyle::ENAS_Right);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-02-19 07:48:37 +08:00
|
|
|
template <> struct ScalarEnumerationTraits<FormatStyle::PointerAlignmentStyle> {
|
|
|
|
static void enumeration(IO &IO, FormatStyle::PointerAlignmentStyle &Value) {
|
2014-06-17 20:40:34 +08:00
|
|
|
IO.enumCase(Value, "Middle", FormatStyle::PAS_Middle);
|
|
|
|
IO.enumCase(Value, "Left", FormatStyle::PAS_Left);
|
|
|
|
IO.enumCase(Value, "Right", FormatStyle::PAS_Right);
|
|
|
|
|
2014-07-15 03:42:55 +08:00
|
|
|
// For backward compatibility.
|
2014-06-17 20:40:34 +08:00
|
|
|
IO.enumCase(Value, "true", FormatStyle::PAS_Left);
|
|
|
|
IO.enumCase(Value, "false", FormatStyle::PAS_Right);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2013-12-10 18:18:34 +08:00
|
|
|
template <>
|
2013-12-10 18:30:34 +08:00
|
|
|
struct ScalarEnumerationTraits<FormatStyle::SpaceBeforeParensOptions> {
|
|
|
|
static void enumeration(IO &IO,
|
|
|
|
FormatStyle::SpaceBeforeParensOptions &Value) {
|
|
|
|
IO.enumCase(Value, "Never", FormatStyle::SBPO_Never);
|
2013-12-10 18:18:34 +08:00
|
|
|
IO.enumCase(Value, "ControlStatements",
|
2013-12-10 18:30:34 +08:00
|
|
|
FormatStyle::SBPO_ControlStatements);
|
|
|
|
IO.enumCase(Value, "Always", FormatStyle::SBPO_Always);
|
2013-12-10 18:18:34 +08:00
|
|
|
|
|
|
|
// For backward compatibility.
|
2013-12-10 18:30:34 +08:00
|
|
|
IO.enumCase(Value, "false", FormatStyle::SBPO_Never);
|
|
|
|
IO.enumCase(Value, "true", FormatStyle::SBPO_ControlStatements);
|
2013-12-10 18:18:34 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2013-12-10 18:30:34 +08:00
|
|
|
template <> struct MappingTraits<FormatStyle> {
|
2013-12-10 19:28:13 +08:00
|
|
|
static void mapping(IO &IO, FormatStyle &Style) {
|
|
|
|
// When reading, read the language first, we need it for getPredefinedStyle.
|
|
|
|
IO.mapOptional("Language", Style.Language);
|
|
|
|
|
2013-05-10 19:56:10 +08:00
|
|
|
if (IO.outputting()) {
|
2015-02-19 07:48:37 +08:00
|
|
|
StringRef StylesArray[] = {"LLVM", "Google", "Chromium",
|
|
|
|
"Mozilla", "WebKit", "GNU"};
|
2013-05-10 19:56:10 +08:00
|
|
|
ArrayRef<StringRef> Styles(StylesArray);
|
|
|
|
for (size_t i = 0, e = Styles.size(); i < e; ++i) {
|
|
|
|
StringRef StyleName(Styles[i]);
|
2013-12-10 18:30:34 +08:00
|
|
|
FormatStyle PredefinedStyle;
|
2013-12-10 19:28:13 +08:00
|
|
|
if (getPredefinedStyle(StyleName, Style.Language, &PredefinedStyle) &&
|
2013-05-19 08:53:30 +08:00
|
|
|
Style == PredefinedStyle) {
|
2013-05-10 19:56:10 +08:00
|
|
|
IO.mapOptional("# BasedOnStyle", StyleName);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2013-05-07 23:32:14 +08:00
|
|
|
StringRef BasedOnStyle;
|
|
|
|
IO.mapOptional("BasedOnStyle", BasedOnStyle);
|
2013-11-29 23:19:43 +08:00
|
|
|
if (!BasedOnStyle.empty()) {
|
2013-12-10 19:28:13 +08:00
|
|
|
FormatStyle::LanguageKind OldLanguage = Style.Language;
|
|
|
|
FormatStyle::LanguageKind Language =
|
|
|
|
((FormatStyle *)IO.getContext())->Language;
|
|
|
|
if (!getPredefinedStyle(BasedOnStyle, Language, &Style)) {
|
2013-05-19 08:53:30 +08:00
|
|
|
IO.setError(Twine("Unknown value for BasedOnStyle: ", BasedOnStyle));
|
|
|
|
return;
|
|
|
|
}
|
2013-12-10 19:28:13 +08:00
|
|
|
Style.Language = OldLanguage;
|
2013-11-29 23:19:43 +08:00
|
|
|
}
|
2013-05-07 23:32:14 +08:00
|
|
|
}
|
|
|
|
|
2015-06-28 22:52:34 +08:00
|
|
|
// For backward compatibility.
|
|
|
|
if (!IO.outputting()) {
|
2017-05-08 23:08:00 +08:00
|
|
|
IO.mapOptional("AlignEscapedNewlinesLeft", Style.AlignEscapedNewlines);
|
2015-06-28 22:52:34 +08:00
|
|
|
IO.mapOptional("DerivePointerBinding", Style.DerivePointerAlignment);
|
|
|
|
IO.mapOptional("IndentFunctionDeclarationAfterType",
|
|
|
|
Style.IndentWrappedFunctionNames);
|
|
|
|
IO.mapOptional("PointerBindsToType", Style.PointerAlignment);
|
|
|
|
IO.mapOptional("SpaceAfterControlStatementKeyword",
|
|
|
|
Style.SpaceBeforeParens);
|
|
|
|
}
|
|
|
|
|
2013-05-07 23:32:14 +08:00
|
|
|
IO.mapOptional("AccessModifierOffset", Style.AccessModifierOffset);
|
2014-11-19 07:55:27 +08:00
|
|
|
IO.mapOptional("AlignAfterOpenBracket", Style.AlignAfterOpenBracket);
|
2015-06-28 22:51:17 +08:00
|
|
|
IO.mapOptional("AlignConsecutiveAssignments",
|
|
|
|
Style.AlignConsecutiveAssignments);
|
2015-10-01 18:06:54 +08:00
|
|
|
IO.mapOptional("AlignConsecutiveDeclarations",
|
|
|
|
Style.AlignConsecutiveDeclarations);
|
2017-05-08 23:08:00 +08:00
|
|
|
IO.mapOptional("AlignEscapedNewlines", Style.AlignEscapedNewlines);
|
2014-12-02 21:24:51 +08:00
|
|
|
IO.mapOptional("AlignOperands", Style.AlignOperands);
|
2013-08-01 07:55:15 +08:00
|
|
|
IO.mapOptional("AlignTrailingComments", Style.AlignTrailingComments);
|
2013-05-07 23:32:14 +08:00
|
|
|
IO.mapOptional("AllowAllParametersOfDeclarationOnNextLine",
|
|
|
|
Style.AllowAllParametersOfDeclarationOnNextLine);
|
2014-05-14 17:33:35 +08:00
|
|
|
IO.mapOptional("AllowShortBlocksOnASingleLine",
|
|
|
|
Style.AllowShortBlocksOnASingleLine);
|
2014-09-10 21:11:45 +08:00
|
|
|
IO.mapOptional("AllowShortCaseLabelsOnASingleLine",
|
|
|
|
Style.AllowShortCaseLabelsOnASingleLine);
|
2015-06-28 22:51:17 +08:00
|
|
|
IO.mapOptional("AllowShortFunctionsOnASingleLine",
|
|
|
|
Style.AllowShortFunctionsOnASingleLine);
|
2013-05-07 23:32:14 +08:00
|
|
|
IO.mapOptional("AllowShortIfStatementsOnASingleLine",
|
|
|
|
Style.AllowShortIfStatementsOnASingleLine);
|
2013-05-16 20:12:21 +08:00
|
|
|
IO.mapOptional("AllowShortLoopsOnASingleLine",
|
|
|
|
Style.AllowShortLoopsOnASingleLine);
|
2014-08-05 20:16:31 +08:00
|
|
|
IO.mapOptional("AlwaysBreakAfterDefinitionReturnType",
|
|
|
|
Style.AlwaysBreakAfterDefinitionReturnType);
|
2015-12-19 06:20:15 +08:00
|
|
|
IO.mapOptional("AlwaysBreakAfterReturnType",
|
|
|
|
Style.AlwaysBreakAfterReturnType);
|
|
|
|
// If AlwaysBreakAfterDefinitionReturnType was specified but
|
|
|
|
// AlwaysBreakAfterReturnType was not, initialize the latter from the
|
|
|
|
// former for backwards compatibility.
|
|
|
|
if (Style.AlwaysBreakAfterDefinitionReturnType != FormatStyle::DRTBS_None &&
|
|
|
|
Style.AlwaysBreakAfterReturnType == FormatStyle::RTBS_None) {
|
|
|
|
if (Style.AlwaysBreakAfterDefinitionReturnType == FormatStyle::DRTBS_All)
|
|
|
|
Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
|
|
|
|
else if (Style.AlwaysBreakAfterDefinitionReturnType ==
|
|
|
|
FormatStyle::DRTBS_TopLevel)
|
|
|
|
Style.AlwaysBreakAfterReturnType =
|
|
|
|
FormatStyle::RTBS_TopLevelDefinitions;
|
|
|
|
}
|
|
|
|
|
2013-07-04 20:02:44 +08:00
|
|
|
IO.mapOptional("AlwaysBreakBeforeMultilineStrings",
|
|
|
|
Style.AlwaysBreakBeforeMultilineStrings);
|
2015-06-28 22:51:17 +08:00
|
|
|
IO.mapOptional("AlwaysBreakTemplateDeclarations",
|
|
|
|
Style.AlwaysBreakTemplateDeclarations);
|
|
|
|
IO.mapOptional("BinPackArguments", Style.BinPackArguments);
|
|
|
|
IO.mapOptional("BinPackParameters", Style.BinPackParameters);
|
2015-09-29 22:57:55 +08:00
|
|
|
IO.mapOptional("BraceWrapping", Style.BraceWrapping);
|
2013-07-27 00:56:36 +08:00
|
|
|
IO.mapOptional("BreakBeforeBinaryOperators",
|
|
|
|
Style.BreakBeforeBinaryOperators);
|
2015-06-28 22:51:17 +08:00
|
|
|
IO.mapOptional("BreakBeforeBraces", Style.BreakBeforeBraces);
|
2013-11-08 08:57:11 +08:00
|
|
|
IO.mapOptional("BreakBeforeTernaryOperators",
|
|
|
|
Style.BreakBeforeTernaryOperators);
|
2013-07-27 00:56:36 +08:00
|
|
|
IO.mapOptional("BreakConstructorInitializersBeforeComma",
|
|
|
|
Style.BreakConstructorInitializersBeforeComma);
|
2016-02-01 19:21:02 +08:00
|
|
|
IO.mapOptional("BreakAfterJavaFieldAnnotations",
|
|
|
|
Style.BreakAfterJavaFieldAnnotations);
|
|
|
|
IO.mapOptional("BreakStringLiterals", Style.BreakStringLiterals);
|
2013-05-07 23:32:14 +08:00
|
|
|
IO.mapOptional("ColumnLimit", Style.ColumnLimit);
|
2015-06-28 22:51:17 +08:00
|
|
|
IO.mapOptional("CommentPragmas", Style.CommentPragmas);
|
2017-03-10 23:10:37 +08:00
|
|
|
IO.mapOptional("BreakBeforeInheritanceComma",
|
|
|
|
Style.BreakBeforeInheritanceComma);
|
2013-05-07 23:32:14 +08:00
|
|
|
IO.mapOptional("ConstructorInitializerAllOnOneLineOrOnePerLine",
|
|
|
|
Style.ConstructorInitializerAllOnOneLineOrOnePerLine);
|
2014-10-29 00:53:38 +08:00
|
|
|
IO.mapOptional("ConstructorInitializerIndentWidth",
|
|
|
|
Style.ConstructorInitializerIndentWidth);
|
2015-06-28 22:51:17 +08:00
|
|
|
IO.mapOptional("ContinuationIndentWidth", Style.ContinuationIndentWidth);
|
|
|
|
IO.mapOptional("Cpp11BracedListStyle", Style.Cpp11BracedListStyle);
|
2014-06-17 20:40:34 +08:00
|
|
|
IO.mapOptional("DerivePointerAlignment", Style.DerivePointerAlignment);
|
2015-06-28 22:51:17 +08:00
|
|
|
IO.mapOptional("DisableFormat", Style.DisableFormat);
|
2013-07-10 22:02:49 +08:00
|
|
|
IO.mapOptional("ExperimentalAutoDetectBinPacking",
|
|
|
|
Style.ExperimentalAutoDetectBinPacking);
|
2017-03-01 23:35:39 +08:00
|
|
|
IO.mapOptional("FixNamespaceComments", Style.FixNamespaceComments);
|
2015-06-28 22:51:17 +08:00
|
|
|
IO.mapOptional("ForEachMacros", Style.ForEachMacros);
|
2015-10-06 19:54:18 +08:00
|
|
|
IO.mapOptional("IncludeCategories", Style.IncludeCategories);
|
2016-03-21 22:11:27 +08:00
|
|
|
IO.mapOptional("IncludeIsMainRegex", Style.IncludeIsMainRegex);
|
2013-05-07 23:32:14 +08:00
|
|
|
IO.mapOptional("IndentCaseLabels", Style.IndentCaseLabels);
|
2015-06-28 22:51:17 +08:00
|
|
|
IO.mapOptional("IndentWidth", Style.IndentWidth);
|
|
|
|
IO.mapOptional("IndentWrappedFunctionNames",
|
|
|
|
Style.IndentWrappedFunctionNames);
|
2016-06-14 00:39:50 +08:00
|
|
|
IO.mapOptional("JavaScriptQuotes", Style.JavaScriptQuotes);
|
|
|
|
IO.mapOptional("JavaScriptWrapImports", Style.JavaScriptWrapImports);
|
2014-03-21 21:43:14 +08:00
|
|
|
IO.mapOptional("KeepEmptyLinesAtTheStartOfBlocks",
|
|
|
|
Style.KeepEmptyLinesAtTheStartOfBlocks);
|
2015-07-04 01:25:16 +08:00
|
|
|
IO.mapOptional("MacroBlockBegin", Style.MacroBlockBegin);
|
|
|
|
IO.mapOptional("MacroBlockEnd", Style.MacroBlockEnd);
|
2015-06-28 22:51:17 +08:00
|
|
|
IO.mapOptional("MaxEmptyLinesToKeep", Style.MaxEmptyLinesToKeep);
|
2013-08-01 07:16:02 +08:00
|
|
|
IO.mapOptional("NamespaceIndentation", Style.NamespaceIndentation);
|
2014-10-29 00:53:38 +08:00
|
|
|
IO.mapOptional("ObjCBlockIndentWidth", Style.ObjCBlockIndentWidth);
|
2014-01-28 23:20:33 +08:00
|
|
|
IO.mapOptional("ObjCSpaceAfterProperty", Style.ObjCSpaceAfterProperty);
|
2013-05-07 23:32:14 +08:00
|
|
|
IO.mapOptional("ObjCSpaceBeforeProtocolList",
|
|
|
|
Style.ObjCSpaceBeforeProtocolList);
|
2013-10-25 22:29:37 +08:00
|
|
|
IO.mapOptional("PenaltyBreakBeforeFirstCallParameter",
|
|
|
|
Style.PenaltyBreakBeforeFirstCallParameter);
|
2013-06-08 00:02:52 +08:00
|
|
|
IO.mapOptional("PenaltyBreakComment", Style.PenaltyBreakComment);
|
2013-07-12 04:41:21 +08:00
|
|
|
IO.mapOptional("PenaltyBreakFirstLessLess",
|
|
|
|
Style.PenaltyBreakFirstLessLess);
|
2015-06-28 22:51:17 +08:00
|
|
|
IO.mapOptional("PenaltyBreakString", Style.PenaltyBreakString);
|
2013-05-07 23:32:14 +08:00
|
|
|
IO.mapOptional("PenaltyExcessCharacter", Style.PenaltyExcessCharacter);
|
|
|
|
IO.mapOptional("PenaltyReturnTypeOnItsOwnLine",
|
|
|
|
Style.PenaltyReturnTypeOnItsOwnLine);
|
2014-06-17 20:40:34 +08:00
|
|
|
IO.mapOptional("PointerAlignment", Style.PointerAlignment);
|
2015-12-01 21:28:53 +08:00
|
|
|
IO.mapOptional("ReflowComments", Style.ReflowComments);
|
|
|
|
IO.mapOptional("SortIncludes", Style.SortIncludes);
|
2015-06-28 22:51:17 +08:00
|
|
|
IO.mapOptional("SpaceAfterCStyleCast", Style.SpaceAfterCStyleCast);
|
2016-08-09 22:24:40 +08:00
|
|
|
IO.mapOptional("SpaceAfterTemplateKeyword", Style.SpaceAfterTemplateKeyword);
|
2015-06-28 22:51:17 +08:00
|
|
|
IO.mapOptional("SpaceBeforeAssignmentOperators",
|
|
|
|
Style.SpaceBeforeAssignmentOperators);
|
|
|
|
IO.mapOptional("SpaceBeforeParens", Style.SpaceBeforeParens);
|
|
|
|
IO.mapOptional("SpaceInEmptyParentheses", Style.SpaceInEmptyParentheses);
|
2013-05-07 23:32:14 +08:00
|
|
|
IO.mapOptional("SpacesBeforeTrailingComments",
|
|
|
|
Style.SpacesBeforeTrailingComments);
|
2013-10-29 22:52:02 +08:00
|
|
|
IO.mapOptional("SpacesInAngles", Style.SpacesInAngles);
|
2014-01-15 23:09:08 +08:00
|
|
|
IO.mapOptional("SpacesInContainerLiterals",
|
|
|
|
Style.SpacesInContainerLiterals);
|
2015-06-28 22:51:17 +08:00
|
|
|
IO.mapOptional("SpacesInCStyleCastParentheses",
|
|
|
|
Style.SpacesInCStyleCastParentheses);
|
|
|
|
IO.mapOptional("SpacesInParentheses", Style.SpacesInParentheses);
|
|
|
|
IO.mapOptional("SpacesInSquareBrackets", Style.SpacesInSquareBrackets);
|
|
|
|
IO.mapOptional("Standard", Style.Standard);
|
|
|
|
IO.mapOptional("TabWidth", Style.TabWidth);
|
|
|
|
IO.mapOptional("UseTab", Style.UseTab);
|
2013-05-07 23:32:14 +08:00
|
|
|
}
|
|
|
|
};
|
2013-11-29 23:19:43 +08:00
|
|
|
|
2015-09-29 22:57:55 +08:00
|
|
|
template <> struct MappingTraits<FormatStyle::BraceWrappingFlags> {
|
|
|
|
static void mapping(IO &IO, FormatStyle::BraceWrappingFlags &Wrapping) {
|
|
|
|
IO.mapOptional("AfterClass", Wrapping.AfterClass);
|
|
|
|
IO.mapOptional("AfterControlStatement", Wrapping.AfterControlStatement);
|
|
|
|
IO.mapOptional("AfterEnum", Wrapping.AfterEnum);
|
|
|
|
IO.mapOptional("AfterFunction", Wrapping.AfterFunction);
|
|
|
|
IO.mapOptional("AfterNamespace", Wrapping.AfterNamespace);
|
|
|
|
IO.mapOptional("AfterObjCDeclaration", Wrapping.AfterObjCDeclaration);
|
|
|
|
IO.mapOptional("AfterStruct", Wrapping.AfterStruct);
|
|
|
|
IO.mapOptional("AfterUnion", Wrapping.AfterUnion);
|
|
|
|
IO.mapOptional("BeforeCatch", Wrapping.BeforeCatch);
|
|
|
|
IO.mapOptional("BeforeElse", Wrapping.BeforeElse);
|
|
|
|
IO.mapOptional("IndentBraces", Wrapping.IndentBraces);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-10-06 19:54:18 +08:00
|
|
|
template <> struct MappingTraits<FormatStyle::IncludeCategory> {
|
|
|
|
static void mapping(IO &IO, FormatStyle::IncludeCategory &Category) {
|
|
|
|
IO.mapOptional("Regex", Category.Regex);
|
|
|
|
IO.mapOptional("Priority", Category.Priority);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2013-11-29 23:19:43 +08:00
|
|
|
// Allows to read vector<FormatStyle> while keeping default values.
|
2013-12-10 19:28:13 +08:00
|
|
|
// IO.getContext() should contain a pointer to the FormatStyle structure, that
|
|
|
|
// will be used to get default values for missing keys.
|
|
|
|
// If the first element has no Language specified, it will be treated as the
|
|
|
|
// default one for the following elements.
|
2015-02-19 07:48:37 +08:00
|
|
|
template <> struct DocumentListTraits<std::vector<FormatStyle>> {
|
2013-12-10 19:28:13 +08:00
|
|
|
static size_t size(IO &IO, std::vector<FormatStyle> &Seq) {
|
|
|
|
return Seq.size();
|
2013-11-29 23:19:43 +08:00
|
|
|
}
|
2013-12-10 19:28:13 +08:00
|
|
|
static FormatStyle &element(IO &IO, std::vector<FormatStyle> &Seq,
|
2013-12-10 18:30:34 +08:00
|
|
|
size_t Index) {
|
2013-12-10 19:28:13 +08:00
|
|
|
if (Index >= Seq.size()) {
|
|
|
|
assert(Index == Seq.size());
|
2013-12-10 18:30:34 +08:00
|
|
|
FormatStyle Template;
|
2013-12-10 19:28:13 +08:00
|
|
|
if (Seq.size() > 0 && Seq[0].Language == FormatStyle::LK_None) {
|
2013-11-29 23:19:43 +08:00
|
|
|
Template = Seq[0];
|
2013-12-10 19:28:13 +08:00
|
|
|
} else {
|
2014-05-09 21:11:16 +08:00
|
|
|
Template = *((const FormatStyle *)IO.getContext());
|
2013-12-10 18:30:34 +08:00
|
|
|
Template.Language = FormatStyle::LK_None;
|
2013-11-29 23:19:43 +08:00
|
|
|
}
|
2013-12-10 19:28:13 +08:00
|
|
|
Seq.resize(Index + 1, Template);
|
2013-11-29 23:19:43 +08:00
|
|
|
}
|
2013-12-10 19:28:13 +08:00
|
|
|
return Seq[Index];
|
2013-11-29 23:19:43 +08:00
|
|
|
}
|
|
|
|
};
|
2015-09-23 16:30:47 +08:00
|
|
|
} // namespace yaml
|
|
|
|
} // namespace llvm
|
2013-05-07 23:32:14 +08:00
|
|
|
|
2012-12-04 02:12:45 +08:00
|
|
|
namespace clang {
|
|
|
|
namespace format {
|
|
|
|
|
2014-06-12 11:31:26 +08:00
|
|
|
const std::error_category &getParseCategory() {
|
2014-06-12 10:50:04 +08:00
|
|
|
static ParseErrorCategory C;
|
|
|
|
return C;
|
|
|
|
}
|
|
|
|
std::error_code make_error_code(ParseError e) {
|
2014-06-12 11:31:26 +08:00
|
|
|
return std::error_code(static_cast<int>(e), getParseCategory());
|
2014-06-12 10:50:04 +08:00
|
|
|
}
|
|
|
|
|
2017-01-17 08:12:27 +08:00
|
|
|
inline llvm::Error make_string_error(const llvm::Twine &Message) {
|
|
|
|
return llvm::make_error<llvm::StringError>(Message,
|
|
|
|
llvm::inconvertibleErrorCode());
|
|
|
|
}
|
|
|
|
|
2016-10-20 07:39:55 +08:00
|
|
|
const char *ParseErrorCategory::name() const noexcept {
|
2014-06-12 10:50:04 +08:00
|
|
|
return "clang-format.parse_error";
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string ParseErrorCategory::message(int EV) const {
|
|
|
|
switch (static_cast<ParseError>(EV)) {
|
|
|
|
case ParseError::Success:
|
|
|
|
return "Success";
|
|
|
|
case ParseError::Error:
|
|
|
|
return "Invalid argument";
|
|
|
|
case ParseError::Unsuitable:
|
|
|
|
return "Unsuitable";
|
|
|
|
}
|
2014-06-13 03:33:26 +08:00
|
|
|
llvm_unreachable("unexpected parse error");
|
2014-06-12 10:50:04 +08:00
|
|
|
}
|
|
|
|
|
2015-09-29 22:57:55 +08:00
|
|
|
static FormatStyle expandPresets(const FormatStyle &Style) {
|
2015-10-07 12:06:10 +08:00
|
|
|
if (Style.BreakBeforeBraces == FormatStyle::BS_Custom)
|
|
|
|
return Style;
|
2015-09-29 22:57:55 +08:00
|
|
|
FormatStyle Expanded = Style;
|
|
|
|
Expanded.BraceWrapping = {false, false, false, false, false, false,
|
|
|
|
false, false, false, false, false};
|
|
|
|
switch (Style.BreakBeforeBraces) {
|
|
|
|
case FormatStyle::BS_Linux:
|
|
|
|
Expanded.BraceWrapping.AfterClass = true;
|
|
|
|
Expanded.BraceWrapping.AfterFunction = true;
|
|
|
|
Expanded.BraceWrapping.AfterNamespace = true;
|
|
|
|
break;
|
|
|
|
case FormatStyle::BS_Mozilla:
|
|
|
|
Expanded.BraceWrapping.AfterClass = true;
|
|
|
|
Expanded.BraceWrapping.AfterEnum = true;
|
|
|
|
Expanded.BraceWrapping.AfterFunction = true;
|
|
|
|
Expanded.BraceWrapping.AfterStruct = true;
|
|
|
|
Expanded.BraceWrapping.AfterUnion = true;
|
|
|
|
break;
|
|
|
|
case FormatStyle::BS_Stroustrup:
|
|
|
|
Expanded.BraceWrapping.AfterFunction = true;
|
|
|
|
Expanded.BraceWrapping.BeforeCatch = true;
|
|
|
|
Expanded.BraceWrapping.BeforeElse = true;
|
|
|
|
break;
|
|
|
|
case FormatStyle::BS_Allman:
|
|
|
|
Expanded.BraceWrapping.AfterClass = true;
|
|
|
|
Expanded.BraceWrapping.AfterControlStatement = true;
|
|
|
|
Expanded.BraceWrapping.AfterEnum = true;
|
|
|
|
Expanded.BraceWrapping.AfterFunction = true;
|
|
|
|
Expanded.BraceWrapping.AfterNamespace = true;
|
|
|
|
Expanded.BraceWrapping.AfterObjCDeclaration = true;
|
|
|
|
Expanded.BraceWrapping.AfterStruct = true;
|
|
|
|
Expanded.BraceWrapping.BeforeCatch = true;
|
|
|
|
Expanded.BraceWrapping.BeforeElse = true;
|
|
|
|
break;
|
|
|
|
case FormatStyle::BS_GNU:
|
|
|
|
Expanded.BraceWrapping = {true, true, true, true, true, true,
|
|
|
|
true, true, true, true, true};
|
|
|
|
break;
|
|
|
|
case FormatStyle::BS_WebKit:
|
|
|
|
Expanded.BraceWrapping.AfterFunction = true;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return Expanded;
|
|
|
|
}
|
|
|
|
|
2012-12-04 02:12:45 +08:00
|
|
|
FormatStyle getLLVMStyle() {
|
|
|
|
FormatStyle LLVMStyle;
|
2013-11-29 23:19:43 +08:00
|
|
|
LLVMStyle.Language = FormatStyle::LK_Cpp;
|
2012-12-04 02:12:45 +08:00
|
|
|
LLVMStyle.AccessModifierOffset = -2;
|
2017-05-08 23:08:00 +08:00
|
|
|
LLVMStyle.AlignEscapedNewlines = FormatStyle::ENAS_Right;
|
2015-10-27 20:38:37 +08:00
|
|
|
LLVMStyle.AlignAfterOpenBracket = FormatStyle::BAS_Align;
|
2014-12-02 21:24:51 +08:00
|
|
|
LLVMStyle.AlignOperands = true;
|
2013-08-01 07:55:15 +08:00
|
|
|
LLVMStyle.AlignTrailingComments = true;
|
2015-04-29 21:06:49 +08:00
|
|
|
LLVMStyle.AlignConsecutiveAssignments = false;
|
2015-10-01 18:06:54 +08:00
|
|
|
LLVMStyle.AlignConsecutiveDeclarations = false;
|
2013-01-30 00:03:49 +08:00
|
|
|
LLVMStyle.AllowAllParametersOfDeclarationOnNextLine = true;
|
2014-04-08 20:46:38 +08:00
|
|
|
LLVMStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
|
2014-05-14 17:33:35 +08:00
|
|
|
LLVMStyle.AllowShortBlocksOnASingleLine = false;
|
2014-09-10 21:11:45 +08:00
|
|
|
LLVMStyle.AllowShortCaseLabelsOnASingleLine = false;
|
2013-01-15 00:24:39 +08:00
|
|
|
LLVMStyle.AllowShortIfStatementsOnASingleLine = false;
|
2013-05-16 20:12:21 +08:00
|
|
|
LLVMStyle.AllowShortLoopsOnASingleLine = false;
|
2015-12-19 06:20:15 +08:00
|
|
|
LLVMStyle.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
|
2015-06-29 23:30:42 +08:00
|
|
|
LLVMStyle.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_None;
|
2013-07-04 20:02:44 +08:00
|
|
|
LLVMStyle.AlwaysBreakBeforeMultilineStrings = false;
|
2013-07-27 00:56:36 +08:00
|
|
|
LLVMStyle.AlwaysBreakTemplateDeclarations = false;
|
2013-05-06 22:11:27 +08:00
|
|
|
LLVMStyle.BinPackParameters = true;
|
2014-10-09 17:52:05 +08:00
|
|
|
LLVMStyle.BinPackArguments = true;
|
2014-09-15 19:11:00 +08:00
|
|
|
LLVMStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
|
2013-11-08 08:57:11 +08:00
|
|
|
LLVMStyle.BreakBeforeTernaryOperators = true;
|
2013-07-27 00:56:36 +08:00
|
|
|
LLVMStyle.BreakBeforeBraces = FormatStyle::BS_Attach;
|
2015-10-07 12:06:10 +08:00
|
|
|
LLVMStyle.BraceWrapping = {false, false, false, false, false, false,
|
|
|
|
false, false, false, false, false};
|
2015-10-16 00:03:01 +08:00
|
|
|
LLVMStyle.BreakAfterJavaFieldAnnotations = false;
|
2016-02-01 19:21:02 +08:00
|
|
|
LLVMStyle.BreakConstructorInitializersBeforeComma = false;
|
2017-03-10 23:10:37 +08:00
|
|
|
LLVMStyle.BreakBeforeInheritanceComma = false;
|
2016-02-01 19:21:02 +08:00
|
|
|
LLVMStyle.BreakStringLiterals = true;
|
2013-05-06 22:11:27 +08:00
|
|
|
LLVMStyle.ColumnLimit = 80;
|
2014-04-01 20:55:11 +08:00
|
|
|
LLVMStyle.CommentPragmas = "^ IWYU pragma:";
|
2013-05-06 22:11:27 +08:00
|
|
|
LLVMStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
|
2013-08-13 18:58:30 +08:00
|
|
|
LLVMStyle.ConstructorInitializerIndentWidth = 4;
|
2014-04-01 20:55:11 +08:00
|
|
|
LLVMStyle.ContinuationIndentWidth = 4;
|
2014-03-02 20:37:31 +08:00
|
|
|
LLVMStyle.Cpp11BracedListStyle = true;
|
2014-06-17 20:40:34 +08:00
|
|
|
LLVMStyle.DerivePointerAlignment = false;
|
2013-07-10 22:02:49 +08:00
|
|
|
LLVMStyle.ExperimentalAutoDetectBinPacking = false;
|
2017-03-01 23:35:39 +08:00
|
|
|
LLVMStyle.FixNamespaceComments = true;
|
2014-04-01 20:55:11 +08:00
|
|
|
LLVMStyle.ForEachMacros.push_back("foreach");
|
|
|
|
LLVMStyle.ForEachMacros.push_back("Q_FOREACH");
|
|
|
|
LLVMStyle.ForEachMacros.push_back("BOOST_FOREACH");
|
2015-09-29 15:53:08 +08:00
|
|
|
LLVMStyle.IncludeCategories = {{"^\"(llvm|llvm-c|clang|clang-c)/", 2},
|
|
|
|
{"^(<|\"(gtest|isl|json)/)", 3},
|
|
|
|
{".*", 1}};
|
2016-03-21 22:11:27 +08:00
|
|
|
LLVMStyle.IncludeIsMainRegex = "$";
|
2013-05-06 22:11:27 +08:00
|
|
|
LLVMStyle.IndentCaseLabels = false;
|
2014-07-09 16:42:42 +08:00
|
|
|
LLVMStyle.IndentWrappedFunctionNames = false;
|
2013-07-27 00:56:36 +08:00
|
|
|
LLVMStyle.IndentWidth = 2;
|
2016-06-14 01:50:10 +08:00
|
|
|
LLVMStyle.JavaScriptQuotes = FormatStyle::JSQS_Leave;
|
|
|
|
LLVMStyle.JavaScriptWrapImports = true;
|
2013-09-05 22:08:34 +08:00
|
|
|
LLVMStyle.TabWidth = 8;
|
2013-05-06 22:11:27 +08:00
|
|
|
LLVMStyle.MaxEmptyLinesToKeep = 1;
|
2014-03-21 21:43:14 +08:00
|
|
|
LLVMStyle.KeepEmptyLinesAtTheStartOfBlocks = true;
|
2013-08-01 07:16:02 +08:00
|
|
|
LLVMStyle.NamespaceIndentation = FormatStyle::NI_None;
|
2014-10-29 00:53:38 +08:00
|
|
|
LLVMStyle.ObjCBlockIndentWidth = 2;
|
2014-01-28 23:20:33 +08:00
|
|
|
LLVMStyle.ObjCSpaceAfterProperty = false;
|
2013-01-11 04:12:55 +08:00
|
|
|
LLVMStyle.ObjCSpaceBeforeProtocolList = true;
|
2014-06-17 20:40:34 +08:00
|
|
|
LLVMStyle.PointerAlignment = FormatStyle::PAS_Right;
|
2013-05-06 22:11:27 +08:00
|
|
|
LLVMStyle.SpacesBeforeTrailingComments = 1;
|
2014-03-02 20:37:31 +08:00
|
|
|
LLVMStyle.Standard = FormatStyle::LS_Cpp11;
|
2013-09-28 00:14:22 +08:00
|
|
|
LLVMStyle.UseTab = FormatStyle::UT_Never;
|
2015-12-01 21:28:53 +08:00
|
|
|
LLVMStyle.ReflowComments = true;
|
2013-08-20 20:36:34 +08:00
|
|
|
LLVMStyle.SpacesInParentheses = false;
|
2014-08-26 19:41:14 +08:00
|
|
|
LLVMStyle.SpacesInSquareBrackets = false;
|
2013-08-20 20:36:34 +08:00
|
|
|
LLVMStyle.SpaceInEmptyParentheses = false;
|
2014-01-15 23:09:08 +08:00
|
|
|
LLVMStyle.SpacesInContainerLiterals = true;
|
2013-08-20 20:36:34 +08:00
|
|
|
LLVMStyle.SpacesInCStyleCastParentheses = false;
|
2014-09-03 15:37:29 +08:00
|
|
|
LLVMStyle.SpaceAfterCStyleCast = false;
|
2016-08-09 22:24:40 +08:00
|
|
|
LLVMStyle.SpaceAfterTemplateKeyword = true;
|
2013-12-10 18:18:34 +08:00
|
|
|
LLVMStyle.SpaceBeforeParens = FormatStyle::SBPO_ControlStatements;
|
2013-09-25 23:15:02 +08:00
|
|
|
LLVMStyle.SpaceBeforeAssignmentOperators = true;
|
2013-10-29 22:52:02 +08:00
|
|
|
LLVMStyle.SpacesInAngles = false;
|
2013-07-12 04:41:21 +08:00
|
|
|
|
2013-12-20 00:45:34 +08:00
|
|
|
LLVMStyle.PenaltyBreakComment = 300;
|
2013-12-10 23:42:15 +08:00
|
|
|
LLVMStyle.PenaltyBreakFirstLessLess = 120;
|
|
|
|
LLVMStyle.PenaltyBreakString = 1000;
|
|
|
|
LLVMStyle.PenaltyExcessCharacter = 1000000;
|
2013-07-12 04:41:21 +08:00
|
|
|
LLVMStyle.PenaltyReturnTypeOnItsOwnLine = 60;
|
2013-10-25 22:29:37 +08:00
|
|
|
LLVMStyle.PenaltyBreakBeforeFirstCallParameter = 19;
|
2013-07-12 04:41:21 +08:00
|
|
|
|
2014-05-22 23:12:22 +08:00
|
|
|
LLVMStyle.DisableFormat = false;
|
2015-11-16 20:38:56 +08:00
|
|
|
LLVMStyle.SortIncludes = true;
|
2014-05-22 23:12:22 +08:00
|
|
|
|
2012-12-04 02:12:45 +08:00
|
|
|
return LLVMStyle;
|
|
|
|
}
|
|
|
|
|
2014-02-03 04:50:45 +08:00
|
|
|
FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language) {
|
2013-12-10 23:42:15 +08:00
|
|
|
FormatStyle GoogleStyle = getLLVMStyle();
|
2014-02-03 04:50:45 +08:00
|
|
|
GoogleStyle.Language = Language;
|
|
|
|
|
2012-12-04 02:12:45 +08:00
|
|
|
GoogleStyle.AccessModifierOffset = -1;
|
2017-05-08 23:08:00 +08:00
|
|
|
GoogleStyle.AlignEscapedNewlines = FormatStyle::ENAS_Left;
|
2013-04-24 21:46:00 +08:00
|
|
|
GoogleStyle.AllowShortIfStatementsOnASingleLine = true;
|
2013-05-24 02:05:18 +08:00
|
|
|
GoogleStyle.AllowShortLoopsOnASingleLine = true;
|
2013-07-04 20:02:44 +08:00
|
|
|
GoogleStyle.AlwaysBreakBeforeMultilineStrings = true;
|
2013-07-27 00:56:36 +08:00
|
|
|
GoogleStyle.AlwaysBreakTemplateDeclarations = true;
|
2013-05-06 22:11:27 +08:00
|
|
|
GoogleStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
|
2014-06-17 20:40:34 +08:00
|
|
|
GoogleStyle.DerivePointerAlignment = true;
|
2015-09-29 15:53:08 +08:00
|
|
|
GoogleStyle.IncludeCategories = {{"^<.*\\.h>", 1}, {"^<.*", 2}, {".*", 3}};
|
2016-03-21 22:11:27 +08:00
|
|
|
GoogleStyle.IncludeIsMainRegex = "([-_](test|unittest))?$";
|
2013-05-06 22:11:27 +08:00
|
|
|
GoogleStyle.IndentCaseLabels = true;
|
2014-03-21 21:43:14 +08:00
|
|
|
GoogleStyle.KeepEmptyLinesAtTheStartOfBlocks = false;
|
2014-01-28 23:20:33 +08:00
|
|
|
GoogleStyle.ObjCSpaceAfterProperty = false;
|
2013-01-11 04:12:55 +08:00
|
|
|
GoogleStyle.ObjCSpaceBeforeProtocolList = false;
|
2014-06-17 20:40:34 +08:00
|
|
|
GoogleStyle.PointerAlignment = FormatStyle::PAS_Left;
|
2013-05-06 22:11:27 +08:00
|
|
|
GoogleStyle.SpacesBeforeTrailingComments = 2;
|
|
|
|
GoogleStyle.Standard = FormatStyle::LS_Auto;
|
2013-07-12 04:41:21 +08:00
|
|
|
|
|
|
|
GoogleStyle.PenaltyReturnTypeOnItsOwnLine = 200;
|
2013-10-25 22:29:37 +08:00
|
|
|
GoogleStyle.PenaltyBreakBeforeFirstCallParameter = 1;
|
2013-07-12 04:41:21 +08:00
|
|
|
|
2014-09-15 19:21:46 +08:00
|
|
|
if (Language == FormatStyle::LK_Java) {
|
2015-10-27 20:38:37 +08:00
|
|
|
GoogleStyle.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
|
2014-12-02 21:24:51 +08:00
|
|
|
GoogleStyle.AlignOperands = false;
|
2015-01-05 04:40:45 +08:00
|
|
|
GoogleStyle.AlignTrailingComments = false;
|
2014-11-26 18:43:58 +08:00
|
|
|
GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
|
2015-01-05 04:40:45 +08:00
|
|
|
GoogleStyle.AllowShortIfStatementsOnASingleLine = false;
|
2015-01-14 20:24:59 +08:00
|
|
|
GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
|
2014-09-15 19:21:46 +08:00
|
|
|
GoogleStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
|
|
|
|
GoogleStyle.ColumnLimit = 100;
|
|
|
|
GoogleStyle.SpaceAfterCStyleCast = true;
|
2014-11-14 16:22:46 +08:00
|
|
|
GoogleStyle.SpacesBeforeTrailingComments = 1;
|
2014-09-15 19:21:46 +08:00
|
|
|
} else if (Language == FormatStyle::LK_JavaScript) {
|
2015-10-27 20:38:37 +08:00
|
|
|
GoogleStyle.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
|
2015-12-21 21:52:19 +08:00
|
|
|
GoogleStyle.AlignOperands = false;
|
2016-09-08 07:01:13 +08:00
|
|
|
GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
|
2015-10-27 20:38:37 +08:00
|
|
|
GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
|
2014-11-06 01:22:31 +08:00
|
|
|
GoogleStyle.BreakBeforeTernaryOperators = false;
|
2017-03-13 17:39:23 +08:00
|
|
|
// taze:, @tag followed by { for a lot of JSDoc tags, and @see, which is
|
|
|
|
// commonly followed by overlong URLs.
|
|
|
|
GoogleStyle.CommentPragmas = "(taze:|(@[A-Za-z_0-9-]+[ \\t]*{)|@see)";
|
2014-05-09 18:28:58 +08:00
|
|
|
GoogleStyle.MaxEmptyLinesToKeep = 3;
|
2016-06-14 00:41:28 +08:00
|
|
|
GoogleStyle.NamespaceIndentation = FormatStyle::NI_All;
|
2014-02-03 04:50:45 +08:00
|
|
|
GoogleStyle.SpacesInContainerLiterals = false;
|
2016-03-03 06:44:03 +08:00
|
|
|
GoogleStyle.JavaScriptQuotes = FormatStyle::JSQS_Single;
|
2016-06-14 00:39:50 +08:00
|
|
|
GoogleStyle.JavaScriptWrapImports = false;
|
2014-02-03 04:50:45 +08:00
|
|
|
} else if (Language == FormatStyle::LK_Proto) {
|
2014-04-08 20:46:38 +08:00
|
|
|
GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
|
2014-04-15 17:54:30 +08:00
|
|
|
GoogleStyle.SpacesInContainerLiterals = false;
|
2016-12-12 20:42:29 +08:00
|
|
|
} else if (Language == FormatStyle::LK_ObjC) {
|
|
|
|
GoogleStyle.ColumnLimit = 100;
|
2014-02-03 04:50:45 +08:00
|
|
|
}
|
2013-12-10 19:28:13 +08:00
|
|
|
|
2014-02-03 04:50:45 +08:00
|
|
|
return GoogleStyle;
|
2014-01-19 17:04:08 +08:00
|
|
|
}
|
|
|
|
|
2014-02-03 04:50:45 +08:00
|
|
|
FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language) {
|
|
|
|
FormatStyle ChromiumStyle = getGoogleStyle(Language);
|
2014-11-27 00:43:18 +08:00
|
|
|
if (Language == FormatStyle::LK_Java) {
|
2015-01-05 04:40:45 +08:00
|
|
|
ChromiumStyle.AllowShortIfStatementsOnASingleLine = true;
|
2015-10-16 00:03:01 +08:00
|
|
|
ChromiumStyle.BreakAfterJavaFieldAnnotations = true;
|
2014-11-27 00:43:18 +08:00
|
|
|
ChromiumStyle.ContinuationIndentWidth = 8;
|
2015-10-16 00:03:01 +08:00
|
|
|
ChromiumStyle.IndentWidth = 4;
|
2017-01-04 10:33:36 +08:00
|
|
|
} else if (Language == FormatStyle::LK_JavaScript) {
|
|
|
|
ChromiumStyle.AllowShortIfStatementsOnASingleLine = false;
|
|
|
|
ChromiumStyle.AllowShortLoopsOnASingleLine = false;
|
2014-11-27 00:43:18 +08:00
|
|
|
} else {
|
|
|
|
ChromiumStyle.AllowAllParametersOfDeclarationOnNextLine = false;
|
|
|
|
ChromiumStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
|
|
|
|
ChromiumStyle.AllowShortIfStatementsOnASingleLine = false;
|
|
|
|
ChromiumStyle.AllowShortLoopsOnASingleLine = false;
|
|
|
|
ChromiumStyle.BinPackParameters = false;
|
|
|
|
ChromiumStyle.DerivePointerAlignment = false;
|
2017-02-01 02:42:05 +08:00
|
|
|
if (Language == FormatStyle::LK_ObjC)
|
|
|
|
ChromiumStyle.ColumnLimit = 80;
|
2014-11-27 00:43:18 +08:00
|
|
|
}
|
2013-01-15 00:24:39 +08:00
|
|
|
return ChromiumStyle;
|
|
|
|
}
|
|
|
|
|
2013-05-06 22:11:27 +08:00
|
|
|
FormatStyle getMozillaStyle() {
|
|
|
|
FormatStyle MozillaStyle = getLLVMStyle();
|
|
|
|
MozillaStyle.AllowAllParametersOfDeclarationOnNextLine = false;
|
2015-06-29 23:18:58 +08:00
|
|
|
MozillaStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
|
2015-12-19 06:20:15 +08:00
|
|
|
MozillaStyle.AlwaysBreakAfterReturnType =
|
2016-12-15 00:09:29 +08:00
|
|
|
FormatStyle::RTBS_TopLevel;
|
2015-06-29 23:30:42 +08:00
|
|
|
MozillaStyle.AlwaysBreakAfterDefinitionReturnType =
|
|
|
|
FormatStyle::DRTBS_TopLevel;
|
2015-06-29 23:18:58 +08:00
|
|
|
MozillaStyle.AlwaysBreakTemplateDeclarations = true;
|
2016-12-15 00:09:29 +08:00
|
|
|
MozillaStyle.BinPackParameters = false;
|
|
|
|
MozillaStyle.BinPackArguments = false;
|
2015-07-12 11:13:54 +08:00
|
|
|
MozillaStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
|
2015-06-29 23:18:58 +08:00
|
|
|
MozillaStyle.BreakConstructorInitializersBeforeComma = true;
|
2017-03-10 23:10:37 +08:00
|
|
|
MozillaStyle.BreakBeforeInheritanceComma = true;
|
2015-06-29 23:18:58 +08:00
|
|
|
MozillaStyle.ConstructorInitializerIndentWidth = 2;
|
|
|
|
MozillaStyle.ContinuationIndentWidth = 2;
|
2014-03-02 20:37:31 +08:00
|
|
|
MozillaStyle.Cpp11BracedListStyle = false;
|
2017-03-01 23:35:39 +08:00
|
|
|
MozillaStyle.FixNamespaceComments = false;
|
2013-05-06 22:11:27 +08:00
|
|
|
MozillaStyle.IndentCaseLabels = true;
|
2014-01-28 23:20:33 +08:00
|
|
|
MozillaStyle.ObjCSpaceAfterProperty = true;
|
2013-05-06 22:11:27 +08:00
|
|
|
MozillaStyle.ObjCSpaceBeforeProtocolList = false;
|
|
|
|
MozillaStyle.PenaltyReturnTypeOnItsOwnLine = 200;
|
2014-06-17 20:40:34 +08:00
|
|
|
MozillaStyle.PointerAlignment = FormatStyle::PAS_Left;
|
2016-08-09 22:24:40 +08:00
|
|
|
MozillaStyle.SpaceAfterTemplateKeyword = false;
|
2013-05-06 22:11:27 +08:00
|
|
|
return MozillaStyle;
|
|
|
|
}
|
|
|
|
|
2013-07-24 21:10:59 +08:00
|
|
|
FormatStyle getWebKitStyle() {
|
|
|
|
FormatStyle Style = getLLVMStyle();
|
2013-08-01 07:16:02 +08:00
|
|
|
Style.AccessModifierOffset = -4;
|
2015-10-27 20:38:37 +08:00
|
|
|
Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
|
2014-12-02 21:24:51 +08:00
|
|
|
Style.AlignOperands = false;
|
2013-08-01 07:55:15 +08:00
|
|
|
Style.AlignTrailingComments = false;
|
2014-09-15 19:11:00 +08:00
|
|
|
Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
|
2015-08-10 21:43:19 +08:00
|
|
|
Style.BreakBeforeBraces = FormatStyle::BS_WebKit;
|
2013-07-27 00:56:36 +08:00
|
|
|
Style.BreakConstructorInitializersBeforeComma = true;
|
2014-03-02 20:37:31 +08:00
|
|
|
Style.Cpp11BracedListStyle = false;
|
2013-08-01 07:16:02 +08:00
|
|
|
Style.ColumnLimit = 0;
|
2017-03-01 23:35:39 +08:00
|
|
|
Style.FixNamespaceComments = false;
|
2013-07-27 00:56:36 +08:00
|
|
|
Style.IndentWidth = 4;
|
2013-08-01 07:16:02 +08:00
|
|
|
Style.NamespaceIndentation = FormatStyle::NI_Inner;
|
2014-10-29 00:53:38 +08:00
|
|
|
Style.ObjCBlockIndentWidth = 4;
|
2014-01-28 23:20:33 +08:00
|
|
|
Style.ObjCSpaceAfterProperty = true;
|
2014-06-17 20:40:34 +08:00
|
|
|
Style.PointerAlignment = FormatStyle::PAS_Left;
|
2013-07-24 21:10:59 +08:00
|
|
|
return Style;
|
|
|
|
}
|
|
|
|
|
2013-12-10 23:42:15 +08:00
|
|
|
FormatStyle getGNUStyle() {
|
|
|
|
FormatStyle Style = getLLVMStyle();
|
2015-06-29 23:30:42 +08:00
|
|
|
Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
|
2015-12-19 06:20:15 +08:00
|
|
|
Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
|
2014-09-15 19:11:00 +08:00
|
|
|
Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
|
2013-12-12 17:49:52 +08:00
|
|
|
Style.BreakBeforeBraces = FormatStyle::BS_GNU;
|
2013-12-10 23:42:15 +08:00
|
|
|
Style.BreakBeforeTernaryOperators = true;
|
2014-03-02 20:37:31 +08:00
|
|
|
Style.Cpp11BracedListStyle = false;
|
2013-12-10 23:42:15 +08:00
|
|
|
Style.ColumnLimit = 79;
|
2017-03-01 23:35:39 +08:00
|
|
|
Style.FixNamespaceComments = false;
|
2013-12-10 23:42:15 +08:00
|
|
|
Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
|
2014-03-02 20:37:31 +08:00
|
|
|
Style.Standard = FormatStyle::LS_Cpp03;
|
2013-12-10 23:42:15 +08:00
|
|
|
return Style;
|
|
|
|
}
|
|
|
|
|
2014-05-22 23:12:22 +08:00
|
|
|
FormatStyle getNoStyle() {
|
|
|
|
FormatStyle NoStyle = getLLVMStyle();
|
|
|
|
NoStyle.DisableFormat = true;
|
2015-11-16 20:38:56 +08:00
|
|
|
NoStyle.SortIncludes = false;
|
2014-05-22 23:12:22 +08:00
|
|
|
return NoStyle;
|
|
|
|
}
|
|
|
|
|
2013-12-10 19:28:13 +08:00
|
|
|
bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
|
|
|
|
FormatStyle *Style) {
|
|
|
|
if (Name.equals_lower("llvm")) {
|
2013-05-19 08:53:30 +08:00
|
|
|
*Style = getLLVMStyle();
|
2013-12-10 19:28:13 +08:00
|
|
|
} else if (Name.equals_lower("chromium")) {
|
2014-02-03 04:50:45 +08:00
|
|
|
*Style = getChromiumStyle(Language);
|
2013-12-10 19:28:13 +08:00
|
|
|
} else if (Name.equals_lower("mozilla")) {
|
2013-05-19 08:53:30 +08:00
|
|
|
*Style = getMozillaStyle();
|
2013-12-10 19:28:13 +08:00
|
|
|
} else if (Name.equals_lower("google")) {
|
2014-02-03 04:50:45 +08:00
|
|
|
*Style = getGoogleStyle(Language);
|
2013-12-10 19:28:13 +08:00
|
|
|
} else if (Name.equals_lower("webkit")) {
|
2013-07-24 21:10:59 +08:00
|
|
|
*Style = getWebKitStyle();
|
2013-12-10 23:42:15 +08:00
|
|
|
} else if (Name.equals_lower("gnu")) {
|
|
|
|
*Style = getGNUStyle();
|
2014-05-22 23:12:22 +08:00
|
|
|
} else if (Name.equals_lower("none")) {
|
|
|
|
*Style = getNoStyle();
|
2013-12-10 19:28:13 +08:00
|
|
|
} else {
|
2013-05-19 08:53:30 +08:00
|
|
|
return false;
|
2013-12-10 19:28:13 +08:00
|
|
|
}
|
2013-05-07 23:32:14 +08:00
|
|
|
|
2013-12-10 19:28:13 +08:00
|
|
|
Style->Language = Language;
|
2013-05-19 08:53:30 +08:00
|
|
|
return true;
|
2013-05-07 23:32:14 +08:00
|
|
|
}
|
|
|
|
|
2014-06-12 22:02:15 +08:00
|
|
|
std::error_code parseConfiguration(StringRef Text, FormatStyle *Style) {
|
2013-11-29 23:19:43 +08:00
|
|
|
assert(Style);
|
2013-12-10 19:28:13 +08:00
|
|
|
FormatStyle::LanguageKind Language = Style->Language;
|
|
|
|
assert(Language != FormatStyle::LK_None);
|
2013-05-20 23:18:01 +08:00
|
|
|
if (Text.trim().empty())
|
2014-06-12 10:50:04 +08:00
|
|
|
return make_error_code(ParseError::Error);
|
2013-11-29 23:19:43 +08:00
|
|
|
|
|
|
|
std::vector<FormatStyle> Styles;
|
2013-05-07 23:32:14 +08:00
|
|
|
llvm::yaml::Input Input(Text);
|
2013-12-10 19:28:13 +08:00
|
|
|
// DocumentListTraits<vector<FormatStyle>> uses the context to get default
|
|
|
|
// values for the fields, keys for which are missing from the configuration.
|
|
|
|
// Mapping also uses the context to get the language to find the correct
|
|
|
|
// base style.
|
|
|
|
Input.setContext(Style);
|
2013-11-29 23:19:43 +08:00
|
|
|
Input >> Styles;
|
|
|
|
if (Input.error())
|
|
|
|
return Input.error();
|
|
|
|
|
2013-12-10 19:28:13 +08:00
|
|
|
for (unsigned i = 0; i < Styles.size(); ++i) {
|
2013-11-29 23:19:43 +08:00
|
|
|
// Ensures that only the first configuration can skip the Language option.
|
2013-12-10 19:28:13 +08:00
|
|
|
if (Styles[i].Language == FormatStyle::LK_None && i != 0)
|
2014-06-12 10:50:04 +08:00
|
|
|
return make_error_code(ParseError::Error);
|
2013-11-29 23:19:43 +08:00
|
|
|
// Ensure that each language is configured at most once.
|
2013-12-10 19:28:13 +08:00
|
|
|
for (unsigned j = 0; j < i; ++j) {
|
|
|
|
if (Styles[i].Language == Styles[j].Language) {
|
|
|
|
DEBUG(llvm::dbgs()
|
|
|
|
<< "Duplicate languages in the config file on positions " << j
|
|
|
|
<< " and " << i << "\n");
|
2014-06-12 10:50:04 +08:00
|
|
|
return make_error_code(ParseError::Error);
|
2013-12-10 19:28:13 +08:00
|
|
|
}
|
2013-11-29 23:19:43 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
// Look for a suitable configuration starting from the end, so we can
|
|
|
|
// find the configuration for the specific language first, and the default
|
2013-12-10 19:28:13 +08:00
|
|
|
// configuration (which can only be at slot 0) after it.
|
|
|
|
for (int i = Styles.size() - 1; i >= 0; --i) {
|
|
|
|
if (Styles[i].Language == Language ||
|
2013-11-29 23:19:43 +08:00
|
|
|
Styles[i].Language == FormatStyle::LK_None) {
|
|
|
|
*Style = Styles[i];
|
2013-12-10 19:28:13 +08:00
|
|
|
Style->Language = Language;
|
2014-06-12 10:50:04 +08:00
|
|
|
return make_error_code(ParseError::Success);
|
2013-11-29 23:19:43 +08:00
|
|
|
}
|
|
|
|
}
|
2014-06-12 10:50:04 +08:00
|
|
|
return make_error_code(ParseError::Unsuitable);
|
2013-05-07 23:32:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
std::string configurationAsText(const FormatStyle &Style) {
|
|
|
|
std::string Text;
|
|
|
|
llvm::raw_string_ostream Stream(Text);
|
|
|
|
llvm::yaml::Output Output(Stream);
|
|
|
|
// We use the same mapping method for input and output, so we need a non-const
|
|
|
|
// reference here.
|
2015-09-29 22:57:55 +08:00
|
|
|
FormatStyle NonConstStyle = expandPresets(Style);
|
2013-05-07 23:32:14 +08:00
|
|
|
Output << NonConstStyle;
|
2013-05-13 20:56:35 +08:00
|
|
|
return Stream.str();
|
2013-05-07 23:32:14 +08:00
|
|
|
}
|
|
|
|
|
2013-07-01 06:29:28 +08:00
|
|
|
namespace {
|
|
|
|
|
2016-09-08 06:48:53 +08:00
|
|
|
class JavaScriptRequoter : public TokenAnalyzer {
|
2016-04-25 23:09:22 +08:00
|
|
|
public:
|
2016-09-08 06:48:53 +08:00
|
|
|
JavaScriptRequoter(const Environment &Env, const FormatStyle &Style)
|
|
|
|
: TokenAnalyzer(Env, Style) {}
|
2016-04-25 23:09:22 +08:00
|
|
|
|
|
|
|
tooling::Replacements
|
|
|
|
analyze(TokenAnnotator &Annotator,
|
|
|
|
SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
|
2016-09-02 22:29:48 +08:00
|
|
|
FormatTokenLexer &Tokens) override {
|
2016-04-25 23:09:22 +08:00
|
|
|
AffectedRangeMgr.computeAffectedLines(AnnotatedLines.begin(),
|
|
|
|
AnnotatedLines.end());
|
2016-09-08 06:48:53 +08:00
|
|
|
tooling::Replacements Result;
|
|
|
|
requoteJSStringLiteral(AnnotatedLines, Result);
|
|
|
|
return Result;
|
2012-12-04 02:12:45 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2016-09-08 06:48:53 +08:00
|
|
|
// Replaces double/single-quoted string literal as appropriate, re-escaping
|
|
|
|
// the contents in the process.
|
2016-03-17 21:03:41 +08:00
|
|
|
void requoteJSStringLiteral(SmallVectorImpl<AnnotatedLine *> &Lines,
|
2016-04-25 23:09:22 +08:00
|
|
|
tooling::Replacements &Result) {
|
2016-03-17 21:03:41 +08:00
|
|
|
for (AnnotatedLine *Line : Lines) {
|
|
|
|
requoteJSStringLiteral(Line->Children, Result);
|
|
|
|
if (!Line->Affected)
|
|
|
|
continue;
|
|
|
|
for (FormatToken *FormatTok = Line->First; FormatTok;
|
|
|
|
FormatTok = FormatTok->Next) {
|
|
|
|
StringRef Input = FormatTok->TokenText;
|
2016-05-12 19:20:32 +08:00
|
|
|
if (FormatTok->Finalized || !FormatTok->isStringLiteral() ||
|
2016-03-17 21:03:41 +08:00
|
|
|
// NB: testing for not starting with a double quote to avoid
|
2016-09-08 06:48:53 +08:00
|
|
|
// breaking `template strings`.
|
2016-04-28 15:52:03 +08:00
|
|
|
(Style.JavaScriptQuotes == FormatStyle::JSQS_Single &&
|
2016-03-17 21:03:41 +08:00
|
|
|
!Input.startswith("\"")) ||
|
2016-04-28 15:52:03 +08:00
|
|
|
(Style.JavaScriptQuotes == FormatStyle::JSQS_Double &&
|
2016-03-17 21:03:41 +08:00
|
|
|
!Input.startswith("\'")))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Change start and end quote.
|
2016-04-28 15:52:03 +08:00
|
|
|
bool IsSingle = Style.JavaScriptQuotes == FormatStyle::JSQS_Single;
|
2016-03-17 21:03:41 +08:00
|
|
|
SourceLocation Start = FormatTok->Tok.getLocation();
|
|
|
|
auto Replace = [&](SourceLocation Start, unsigned Length,
|
|
|
|
StringRef ReplacementText) {
|
2016-08-01 18:16:37 +08:00
|
|
|
auto Err = Result.add(tooling::Replacement(
|
|
|
|
Env.getSourceManager(), Start, Length, ReplacementText));
|
|
|
|
// FIXME: handle error. For now, print error message and skip the
|
|
|
|
// replacement for release version.
|
2016-12-23 19:40:44 +08:00
|
|
|
if (Err) {
|
2016-08-01 18:16:37 +08:00
|
|
|
llvm::errs() << llvm::toString(std::move(Err)) << "\n";
|
2016-12-23 19:40:44 +08:00
|
|
|
assert(false);
|
|
|
|
}
|
2016-03-17 21:03:41 +08:00
|
|
|
};
|
|
|
|
Replace(Start, 1, IsSingle ? "'" : "\"");
|
|
|
|
Replace(FormatTok->Tok.getEndLoc().getLocWithOffset(-1), 1,
|
|
|
|
IsSingle ? "'" : "\"");
|
|
|
|
|
|
|
|
// Escape internal quotes.
|
|
|
|
bool Escaped = false;
|
|
|
|
for (size_t i = 1; i < Input.size() - 1; i++) {
|
|
|
|
switch (Input[i]) {
|
2016-04-25 23:09:22 +08:00
|
|
|
case '\\':
|
|
|
|
if (!Escaped && i + 1 < Input.size() &&
|
|
|
|
((IsSingle && Input[i + 1] == '"') ||
|
|
|
|
(!IsSingle && Input[i + 1] == '\''))) {
|
|
|
|
// Remove this \, it's escaping a " or ' that no longer needs
|
|
|
|
// escaping
|
|
|
|
Replace(Start.getLocWithOffset(i), 1, "");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
Escaped = !Escaped;
|
|
|
|
break;
|
|
|
|
case '\"':
|
|
|
|
case '\'':
|
|
|
|
if (!Escaped && IsSingle == (Input[i] == '\'')) {
|
|
|
|
// Escape the quote.
|
|
|
|
Replace(Start.getLocWithOffset(i), 0, "\\");
|
|
|
|
}
|
|
|
|
Escaped = false;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
Escaped = false;
|
|
|
|
break;
|
2016-03-17 21:03:41 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-09-08 06:48:53 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
class Formatter : public TokenAnalyzer {
|
|
|
|
public:
|
|
|
|
Formatter(const Environment &Env, const FormatStyle &Style,
|
2017-04-21 22:35:20 +08:00
|
|
|
FormattingAttemptStatus *Status)
|
|
|
|
: TokenAnalyzer(Env, Style), Status(Status) {}
|
2016-09-08 06:48:53 +08:00
|
|
|
|
|
|
|
tooling::Replacements
|
|
|
|
analyze(TokenAnnotator &Annotator,
|
|
|
|
SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
|
|
|
|
FormatTokenLexer &Tokens) override {
|
|
|
|
tooling::Replacements Result;
|
|
|
|
deriveLocalStyle(AnnotatedLines);
|
|
|
|
AffectedRangeMgr.computeAffectedLines(AnnotatedLines.begin(),
|
|
|
|
AnnotatedLines.end());
|
|
|
|
for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
|
|
|
|
Annotator.calculateFormattingInformation(*AnnotatedLines[i]);
|
|
|
|
}
|
|
|
|
Annotator.setCommentLineLevels(AnnotatedLines);
|
|
|
|
|
|
|
|
WhitespaceManager Whitespaces(
|
|
|
|
Env.getSourceManager(), Style,
|
|
|
|
inputUsesCRLF(Env.getSourceManager().getBufferData(Env.getFileID())));
|
|
|
|
ContinuationIndenter Indenter(Style, Tokens.getKeywords(),
|
|
|
|
Env.getSourceManager(), Whitespaces, Encoding,
|
|
|
|
BinPackInconclusiveFunctions);
|
|
|
|
UnwrappedLineFormatter(&Indenter, &Whitespaces, Style, Tokens.getKeywords(),
|
2017-04-21 22:35:20 +08:00
|
|
|
Env.getSourceManager(), Status)
|
2016-09-08 06:48:53 +08:00
|
|
|
.format(AnnotatedLines);
|
|
|
|
for (const auto &R : Whitespaces.generateReplacements())
|
|
|
|
if (Result.add(R))
|
|
|
|
return Result;
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2016-03-17 21:03:41 +08:00
|
|
|
|
2013-09-11 20:25:57 +08:00
|
|
|
static bool inputUsesCRLF(StringRef Text) {
|
|
|
|
return Text.count('\r') * 2 > Text.count('\n');
|
|
|
|
}
|
|
|
|
|
2015-07-19 00:35:30 +08:00
|
|
|
bool
|
|
|
|
hasCpp03IncompatibleFormat(const SmallVectorImpl<AnnotatedLine *> &Lines) {
|
2016-04-25 23:09:22 +08:00
|
|
|
for (const AnnotatedLine *Line : Lines) {
|
2015-07-19 00:35:30 +08:00
|
|
|
if (hasCpp03IncompatibleFormat(Line->Children))
|
|
|
|
return true;
|
|
|
|
for (FormatToken *Tok = Line->First->Next; Tok; Tok = Tok->Next) {
|
|
|
|
if (Tok->WhitespaceRange.getBegin() == Tok->WhitespaceRange.getEnd()) {
|
|
|
|
if (Tok->is(tok::coloncolon) && Tok->Previous->is(TT_TemplateOpener))
|
|
|
|
return true;
|
|
|
|
if (Tok->is(TT_TemplateCloser) &&
|
|
|
|
Tok->Previous->is(TT_TemplateCloser))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
int countVariableAlignments(const SmallVectorImpl<AnnotatedLine *> &Lines) {
|
|
|
|
int AlignmentDiff = 0;
|
2016-04-25 23:09:22 +08:00
|
|
|
for (const AnnotatedLine *Line : Lines) {
|
2015-07-19 00:35:30 +08:00
|
|
|
AlignmentDiff += countVariableAlignments(Line->Children);
|
|
|
|
for (FormatToken *Tok = Line->First; Tok && Tok->Next; Tok = Tok->Next) {
|
|
|
|
if (!Tok->is(TT_PointerOrReference))
|
|
|
|
continue;
|
|
|
|
bool SpaceBefore =
|
|
|
|
Tok->WhitespaceRange.getBegin() != Tok->WhitespaceRange.getEnd();
|
|
|
|
bool SpaceAfter = Tok->Next->WhitespaceRange.getBegin() !=
|
|
|
|
Tok->Next->WhitespaceRange.getEnd();
|
|
|
|
if (SpaceBefore && !SpaceAfter)
|
|
|
|
++AlignmentDiff;
|
|
|
|
if (!SpaceBefore && SpaceAfter)
|
|
|
|
--AlignmentDiff;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return AlignmentDiff;
|
|
|
|
}
|
|
|
|
|
2013-10-12 05:25:45 +08:00
|
|
|
void
|
|
|
|
deriveLocalStyle(const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
|
2013-07-10 22:02:49 +08:00
|
|
|
bool HasBinPackedFunction = false;
|
|
|
|
bool HasOnePerLineFunction = false;
|
2013-03-13 22:41:29 +08:00
|
|
|
for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
|
2013-09-05 17:29:45 +08:00
|
|
|
if (!AnnotatedLines[i]->First->Next)
|
2013-03-13 22:41:29 +08:00
|
|
|
continue;
|
2013-09-05 17:29:45 +08:00
|
|
|
FormatToken *Tok = AnnotatedLines[i]->First->Next;
|
2013-05-29 22:47:47 +08:00
|
|
|
while (Tok->Next) {
|
2013-07-10 22:02:49 +08:00
|
|
|
if (Tok->PackingKind == PPK_BinPacked)
|
|
|
|
HasBinPackedFunction = true;
|
|
|
|
if (Tok->PackingKind == PPK_OnePerLine)
|
|
|
|
HasOnePerLineFunction = true;
|
|
|
|
|
2013-05-29 22:47:47 +08:00
|
|
|
Tok = Tok->Next;
|
2013-03-13 22:41:29 +08:00
|
|
|
}
|
|
|
|
}
|
2016-04-28 15:52:03 +08:00
|
|
|
if (Style.DerivePointerAlignment)
|
|
|
|
Style.PointerAlignment = countVariableAlignments(AnnotatedLines) <= 0
|
|
|
|
? FormatStyle::PAS_Left
|
|
|
|
: FormatStyle::PAS_Right;
|
|
|
|
if (Style.Standard == FormatStyle::LS_Auto)
|
|
|
|
Style.Standard = hasCpp03IncompatibleFormat(AnnotatedLines)
|
|
|
|
? FormatStyle::LS_Cpp11
|
|
|
|
: FormatStyle::LS_Cpp03;
|
2013-07-10 22:02:49 +08:00
|
|
|
BinPackInconclusiveFunctions =
|
|
|
|
HasBinPackedFunction || !HasOnePerLineFunction;
|
2013-03-13 22:41:29 +08:00
|
|
|
}
|
|
|
|
|
2016-04-25 23:09:22 +08:00
|
|
|
bool BinPackInconclusiveFunctions;
|
2017-04-21 22:35:20 +08:00
|
|
|
FormattingAttemptStatus *Status;
|
2016-04-25 23:09:22 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
// This class clean up the erroneous/redundant code around the given ranges in
|
|
|
|
// file.
|
|
|
|
class Cleaner : public TokenAnalyzer {
|
|
|
|
public:
|
2016-04-28 15:52:03 +08:00
|
|
|
Cleaner(const Environment &Env, const FormatStyle &Style)
|
|
|
|
: TokenAnalyzer(Env, Style),
|
2016-04-25 23:09:22 +08:00
|
|
|
DeletedTokens(FormatTokenLess(Env.getSourceManager())) {}
|
|
|
|
|
|
|
|
// FIXME: eliminate unused parameters.
|
|
|
|
tooling::Replacements
|
|
|
|
analyze(TokenAnnotator &Annotator,
|
|
|
|
SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
|
2016-09-02 22:29:48 +08:00
|
|
|
FormatTokenLexer &Tokens) override {
|
2016-04-25 23:09:22 +08:00
|
|
|
// FIXME: in the current implementation the granularity of affected range
|
|
|
|
// is an annotated line. However, this is not sufficient. Furthermore,
|
|
|
|
// redundant code introduced by replacements does not necessarily
|
|
|
|
// intercept with ranges of replacements that result in the redundancy.
|
|
|
|
// To determine if some redundant code is actually introduced by
|
|
|
|
// replacements(e.g. deletions), we need to come up with a more
|
|
|
|
// sophisticated way of computing affected ranges.
|
|
|
|
AffectedRangeMgr.computeAffectedLines(AnnotatedLines.begin(),
|
|
|
|
AnnotatedLines.end());
|
|
|
|
|
|
|
|
checkEmptyNamespace(AnnotatedLines);
|
|
|
|
|
2016-05-18 16:02:56 +08:00
|
|
|
for (auto &Line : AnnotatedLines) {
|
|
|
|
if (Line->Affected) {
|
|
|
|
cleanupRight(Line->First, tok::comma, tok::comma);
|
|
|
|
cleanupRight(Line->First, TT_CtorInitializerColon, tok::comma);
|
2016-09-13 23:02:43 +08:00
|
|
|
cleanupRight(Line->First, tok::l_paren, tok::comma);
|
|
|
|
cleanupLeft(Line->First, tok::comma, tok::r_paren);
|
2016-05-18 16:02:56 +08:00
|
|
|
cleanupLeft(Line->First, TT_CtorInitializerComma, tok::l_brace);
|
|
|
|
cleanupLeft(Line->First, TT_CtorInitializerColon, tok::l_brace);
|
2016-10-20 22:58:45 +08:00
|
|
|
cleanupLeft(Line->First, TT_CtorInitializerColon, tok::equal);
|
2016-05-18 16:02:56 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-25 23:09:22 +08:00
|
|
|
return generateFixes();
|
2013-10-12 05:25:45 +08:00
|
|
|
}
|
|
|
|
|
2016-04-25 23:09:22 +08:00
|
|
|
private:
|
|
|
|
bool containsOnlyComments(const AnnotatedLine &Line) {
|
|
|
|
for (FormatToken *Tok = Line.First; Tok != nullptr; Tok = Tok->Next) {
|
|
|
|
if (Tok->isNot(tok::comment))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
2012-12-04 02:12:45 +08:00
|
|
|
}
|
|
|
|
|
2016-04-25 23:09:22 +08:00
|
|
|
// Iterate through all lines and remove any empty (nested) namespaces.
|
|
|
|
void checkEmptyNamespace(SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
|
2016-10-05 23:49:01 +08:00
|
|
|
std::set<unsigned> DeletedLines;
|
2016-04-25 23:09:22 +08:00
|
|
|
for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
|
|
|
|
auto &Line = *AnnotatedLines[i];
|
|
|
|
if (Line.startsWith(tok::kw_namespace) ||
|
|
|
|
Line.startsWith(tok::kw_inline, tok::kw_namespace)) {
|
2016-10-05 23:49:01 +08:00
|
|
|
checkEmptyNamespace(AnnotatedLines, i, i, DeletedLines);
|
2016-04-25 23:09:22 +08:00
|
|
|
}
|
|
|
|
}
|
2013-06-05 22:09:10 +08:00
|
|
|
|
2016-04-25 23:09:22 +08:00
|
|
|
for (auto Line : DeletedLines) {
|
|
|
|
FormatToken *Tok = AnnotatedLines[Line]->First;
|
|
|
|
while (Tok) {
|
|
|
|
deleteToken(Tok);
|
|
|
|
Tok = Tok->Next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// The function checks if the namespace, which starts from \p CurrentLine, and
|
|
|
|
// its nested namespaces are empty and delete them if they are empty. It also
|
|
|
|
// sets \p NewLine to the last line checked.
|
|
|
|
// Returns true if the current namespace is empty.
|
|
|
|
bool checkEmptyNamespace(SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
|
2016-10-05 23:49:01 +08:00
|
|
|
unsigned CurrentLine, unsigned &NewLine,
|
|
|
|
std::set<unsigned> &DeletedLines) {
|
2016-04-25 23:09:22 +08:00
|
|
|
unsigned InitLine = CurrentLine, End = AnnotatedLines.size();
|
2016-04-28 15:52:03 +08:00
|
|
|
if (Style.BraceWrapping.AfterNamespace) {
|
2016-04-25 23:09:22 +08:00
|
|
|
// If the left brace is in a new line, we should consume it first so that
|
|
|
|
// it does not make the namespace non-empty.
|
|
|
|
// FIXME: error handling if there is no left brace.
|
|
|
|
if (!AnnotatedLines[++CurrentLine]->startsWith(tok::l_brace)) {
|
|
|
|
NewLine = CurrentLine;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
} else if (!AnnotatedLines[CurrentLine]->endsWith(tok::l_brace)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
while (++CurrentLine < End) {
|
|
|
|
if (AnnotatedLines[CurrentLine]->startsWith(tok::r_brace))
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (AnnotatedLines[CurrentLine]->startsWith(tok::kw_namespace) ||
|
|
|
|
AnnotatedLines[CurrentLine]->startsWith(tok::kw_inline,
|
|
|
|
tok::kw_namespace)) {
|
2016-10-05 23:49:01 +08:00
|
|
|
if (!checkEmptyNamespace(AnnotatedLines, CurrentLine, NewLine,
|
|
|
|
DeletedLines))
|
2016-04-25 23:09:22 +08:00
|
|
|
return false;
|
|
|
|
CurrentLine = NewLine;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (containsOnlyComments(*AnnotatedLines[CurrentLine]))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// If there is anything other than comments or nested namespaces in the
|
|
|
|
// current namespace, the namespace cannot be empty.
|
|
|
|
NewLine = CurrentLine;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
NewLine = CurrentLine;
|
|
|
|
if (CurrentLine >= End)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Check if the empty namespace is actually affected by changed ranges.
|
|
|
|
if (!AffectedRangeMgr.affectsCharSourceRange(CharSourceRange::getCharRange(
|
|
|
|
AnnotatedLines[InitLine]->First->Tok.getLocation(),
|
|
|
|
AnnotatedLines[CurrentLine]->Last->Tok.getEndLoc())))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
for (unsigned i = InitLine; i <= CurrentLine; ++i) {
|
|
|
|
DeletedLines.insert(i);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2016-05-18 16:02:56 +08:00
|
|
|
// Checks pairs {start, start->next},..., {end->previous, end} and deletes one
|
|
|
|
// of the token in the pair if the left token has \p LK token kind and the
|
|
|
|
// right token has \p RK token kind. If \p DeleteLeft is true, the left token
|
|
|
|
// is deleted on match; otherwise, the right token is deleted.
|
|
|
|
template <typename LeftKind, typename RightKind>
|
|
|
|
void cleanupPair(FormatToken *Start, LeftKind LK, RightKind RK,
|
|
|
|
bool DeleteLeft) {
|
|
|
|
auto NextNotDeleted = [this](const FormatToken &Tok) -> FormatToken * {
|
|
|
|
for (auto *Res = Tok.Next; Res; Res = Res->Next)
|
|
|
|
if (!Res->is(tok::comment) &&
|
|
|
|
DeletedTokens.find(Res) == DeletedTokens.end())
|
|
|
|
return Res;
|
|
|
|
return nullptr;
|
|
|
|
};
|
|
|
|
for (auto *Left = Start; Left;) {
|
|
|
|
auto *Right = NextNotDeleted(*Left);
|
|
|
|
if (!Right)
|
|
|
|
break;
|
|
|
|
if (Left->is(LK) && Right->is(RK)) {
|
|
|
|
deleteToken(DeleteLeft ? Left : Right);
|
2016-09-10 01:50:49 +08:00
|
|
|
for (auto *Tok = Left->Next; Tok && Tok != Right; Tok = Tok->Next)
|
|
|
|
deleteToken(Tok);
|
2016-05-18 16:02:56 +08:00
|
|
|
// If the right token is deleted, we should keep the left token
|
|
|
|
// unchanged and pair it with the new right token.
|
|
|
|
if (!DeleteLeft)
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
Left = Right;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename LeftKind, typename RightKind>
|
|
|
|
void cleanupLeft(FormatToken *Start, LeftKind LK, RightKind RK) {
|
|
|
|
cleanupPair(Start, LK, RK, /*DeleteLeft=*/true);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename LeftKind, typename RightKind>
|
|
|
|
void cleanupRight(FormatToken *Start, LeftKind LK, RightKind RK) {
|
|
|
|
cleanupPair(Start, LK, RK, /*DeleteLeft=*/false);
|
|
|
|
}
|
|
|
|
|
2016-04-25 23:09:22 +08:00
|
|
|
// Delete the given token.
|
|
|
|
inline void deleteToken(FormatToken *Tok) {
|
|
|
|
if (Tok)
|
|
|
|
DeletedTokens.insert(Tok);
|
|
|
|
}
|
|
|
|
|
|
|
|
tooling::Replacements generateFixes() {
|
|
|
|
tooling::Replacements Fixes;
|
|
|
|
std::vector<FormatToken *> Tokens;
|
|
|
|
std::copy(DeletedTokens.begin(), DeletedTokens.end(),
|
|
|
|
std::back_inserter(Tokens));
|
|
|
|
|
|
|
|
// Merge multiple continuous token deletions into one big deletion so that
|
|
|
|
// the number of replacements can be reduced. This makes computing affected
|
|
|
|
// ranges more efficient when we run reformat on the changed code.
|
|
|
|
unsigned Idx = 0;
|
|
|
|
while (Idx < Tokens.size()) {
|
|
|
|
unsigned St = Idx, End = Idx;
|
|
|
|
while ((End + 1) < Tokens.size() &&
|
|
|
|
Tokens[End]->Next == Tokens[End + 1]) {
|
|
|
|
End++;
|
|
|
|
}
|
|
|
|
auto SR = CharSourceRange::getCharRange(Tokens[St]->Tok.getLocation(),
|
|
|
|
Tokens[End]->Tok.getEndLoc());
|
2016-08-01 18:16:37 +08:00
|
|
|
auto Err =
|
|
|
|
Fixes.add(tooling::Replacement(Env.getSourceManager(), SR, ""));
|
|
|
|
// FIXME: better error handling. for now just print error message and skip
|
|
|
|
// for the release version.
|
2016-12-23 19:40:44 +08:00
|
|
|
if (Err) {
|
2016-08-01 18:16:37 +08:00
|
|
|
llvm::errs() << llvm::toString(std::move(Err)) << "\n";
|
2016-12-23 19:40:44 +08:00
|
|
|
assert(false && "Fixes must not conflict!");
|
|
|
|
}
|
2016-04-25 23:09:22 +08:00
|
|
|
Idx = End + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return Fixes;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Class for less-than inequality comparason for the set `RedundantTokens`.
|
|
|
|
// We store tokens in the order they appear in the translation unit so that
|
|
|
|
// we do not need to sort them in `generateFixes()`.
|
|
|
|
struct FormatTokenLess {
|
2016-04-28 15:52:03 +08:00
|
|
|
FormatTokenLess(const SourceManager &SM) : SM(SM) {}
|
2016-04-25 23:09:22 +08:00
|
|
|
|
2016-05-18 16:14:49 +08:00
|
|
|
bool operator()(const FormatToken *LHS, const FormatToken *RHS) const {
|
2016-04-25 23:09:22 +08:00
|
|
|
return SM.isBeforeInTranslationUnit(LHS->Tok.getLocation(),
|
|
|
|
RHS->Tok.getLocation());
|
|
|
|
}
|
2016-04-28 15:52:03 +08:00
|
|
|
const SourceManager &SM;
|
2016-04-25 23:09:22 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
// Tokens to be deleted.
|
|
|
|
std::set<FormatToken *, FormatTokenLess> DeletedTokens;
|
2012-12-04 02:12:45 +08:00
|
|
|
};
|
|
|
|
|
2015-09-23 16:30:47 +08:00
|
|
|
struct IncludeDirective {
|
|
|
|
StringRef Filename;
|
|
|
|
StringRef Text;
|
|
|
|
unsigned Offset;
|
2015-12-16 18:10:16 +08:00
|
|
|
int Category;
|
2015-09-23 16:30:47 +08:00
|
|
|
};
|
|
|
|
|
2013-07-01 06:29:28 +08:00
|
|
|
} // end anonymous namespace
|
|
|
|
|
2015-09-23 16:30:47 +08:00
|
|
|
// Determines whether 'Ranges' intersects with ('Start', 'End').
|
|
|
|
static bool affectsRange(ArrayRef<tooling::Range> Ranges, unsigned Start,
|
|
|
|
unsigned End) {
|
|
|
|
for (auto Range : Ranges) {
|
|
|
|
if (Range.getOffset() < End &&
|
|
|
|
Range.getOffset() + Range.getLength() > Start)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-08-10 17:32:23 +08:00
|
|
|
// Returns a pair (Index, OffsetToEOL) describing the position of the cursor
|
|
|
|
// before sorting/deduplicating. Index is the index of the include under the
|
|
|
|
// cursor in the original set of includes. If this include has duplicates, it is
|
|
|
|
// the index of the first of the duplicates as the others are going to be
|
|
|
|
// removed. OffsetToEOL describes the cursor's position relative to the end of
|
|
|
|
// its current line.
|
|
|
|
// If `Cursor` is not on any #include, `Index` will be UINT_MAX.
|
|
|
|
static std::pair<unsigned, unsigned>
|
|
|
|
FindCursorIndex(const SmallVectorImpl<IncludeDirective> &Includes,
|
|
|
|
const SmallVectorImpl<unsigned> &Indices, unsigned Cursor) {
|
|
|
|
unsigned CursorIndex = UINT_MAX;
|
|
|
|
unsigned OffsetToEOL = 0;
|
|
|
|
for (int i = 0, e = Includes.size(); i != e; ++i) {
|
|
|
|
unsigned Start = Includes[Indices[i]].Offset;
|
|
|
|
unsigned End = Start + Includes[Indices[i]].Text.size();
|
|
|
|
if (!(Cursor >= Start && Cursor < End))
|
|
|
|
continue;
|
|
|
|
CursorIndex = Indices[i];
|
|
|
|
OffsetToEOL = End - Cursor;
|
|
|
|
// Put the cursor on the only remaining #include among the duplicate
|
|
|
|
// #includes.
|
|
|
|
while (--i >= 0 && Includes[CursorIndex].Text == Includes[Indices[i]].Text)
|
|
|
|
CursorIndex = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return std::make_pair(CursorIndex, OffsetToEOL);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Sorts and deduplicate a block of includes given by 'Includes' alphabetically
|
|
|
|
// adding the necessary replacement to 'Replaces'. 'Includes' must be in strict
|
|
|
|
// source order.
|
|
|
|
// #include directives with the same text will be deduplicated, and only the
|
|
|
|
// first #include in the duplicate #includes remains. If the `Cursor` is
|
|
|
|
// provided and put on a deleted #include, it will be moved to the remaining
|
|
|
|
// #include in the duplicate #includes.
|
2016-05-20 19:24:24 +08:00
|
|
|
static void sortCppIncludes(const FormatStyle &Style,
|
2016-08-10 17:32:23 +08:00
|
|
|
const SmallVectorImpl<IncludeDirective> &Includes,
|
|
|
|
ArrayRef<tooling::Range> Ranges, StringRef FileName,
|
|
|
|
tooling::Replacements &Replaces, unsigned *Cursor) {
|
|
|
|
unsigned IncludesBeginOffset = Includes.front().Offset;
|
2016-08-31 05:33:41 +08:00
|
|
|
unsigned IncludesEndOffset =
|
|
|
|
Includes.back().Offset + Includes.back().Text.size();
|
|
|
|
unsigned IncludesBlockSize = IncludesEndOffset - IncludesBeginOffset;
|
|
|
|
if (!affectsRange(Ranges, IncludesBeginOffset, IncludesEndOffset))
|
2015-09-23 16:30:47 +08:00
|
|
|
return;
|
|
|
|
SmallVector<unsigned, 16> Indices;
|
|
|
|
for (unsigned i = 0, e = Includes.size(); i != e; ++i)
|
|
|
|
Indices.push_back(i);
|
2016-03-04 01:34:14 +08:00
|
|
|
std::stable_sort(
|
|
|
|
Indices.begin(), Indices.end(), [&](unsigned LHSI, unsigned RHSI) {
|
|
|
|
return std::tie(Includes[LHSI].Category, Includes[LHSI].Filename) <
|
|
|
|
std::tie(Includes[RHSI].Category, Includes[RHSI].Filename);
|
|
|
|
});
|
2016-08-10 17:32:23 +08:00
|
|
|
// The index of the include on which the cursor will be put after
|
|
|
|
// sorting/deduplicating.
|
|
|
|
unsigned CursorIndex;
|
|
|
|
// The offset from cursor to the end of line.
|
|
|
|
unsigned CursorToEOLOffset;
|
|
|
|
if (Cursor)
|
|
|
|
std::tie(CursorIndex, CursorToEOLOffset) =
|
|
|
|
FindCursorIndex(Includes, Indices, *Cursor);
|
|
|
|
|
|
|
|
// Deduplicate #includes.
|
|
|
|
Indices.erase(std::unique(Indices.begin(), Indices.end(),
|
|
|
|
[&](unsigned LHSI, unsigned RHSI) {
|
|
|
|
return Includes[LHSI].Text == Includes[RHSI].Text;
|
|
|
|
}),
|
|
|
|
Indices.end());
|
2015-09-23 16:30:47 +08:00
|
|
|
|
|
|
|
// If the #includes are out of order, we generate a single replacement fixing
|
|
|
|
// the entire block. Otherwise, no replacement is generated.
|
2016-08-10 17:32:23 +08:00
|
|
|
if (Indices.size() == Includes.size() &&
|
|
|
|
std::is_sorted(Indices.begin(), Indices.end()))
|
2015-09-23 16:30:47 +08:00
|
|
|
return;
|
|
|
|
|
2015-11-23 16:36:35 +08:00
|
|
|
std::string result;
|
|
|
|
for (unsigned Index : Indices) {
|
|
|
|
if (!result.empty())
|
|
|
|
result += "\n";
|
|
|
|
result += Includes[Index].Text;
|
2016-08-10 17:32:23 +08:00
|
|
|
if (Cursor && CursorIndex == Index)
|
|
|
|
*Cursor = IncludesBeginOffset + result.size() - CursorToEOLOffset;
|
2015-09-23 16:30:47 +08:00
|
|
|
}
|
|
|
|
|
2016-08-01 18:16:37 +08:00
|
|
|
auto Err = Replaces.add(tooling::Replacement(
|
2016-08-10 17:32:23 +08:00
|
|
|
FileName, Includes.front().Offset, IncludesBlockSize, result));
|
2016-08-01 18:16:37 +08:00
|
|
|
// FIXME: better error handling. For now, just skip the replacement for the
|
|
|
|
// release version.
|
2016-12-23 19:40:44 +08:00
|
|
|
if (Err) {
|
2016-08-01 18:16:37 +08:00
|
|
|
llvm::errs() << llvm::toString(std::move(Err)) << "\n";
|
2016-12-23 19:40:44 +08:00
|
|
|
assert(false);
|
|
|
|
}
|
2015-09-23 16:30:47 +08:00
|
|
|
}
|
|
|
|
|
2016-05-31 21:34:20 +08:00
|
|
|
namespace {
|
|
|
|
|
|
|
|
// This class manages priorities of #include categories and calculates
|
|
|
|
// priorities for headers.
|
|
|
|
class IncludeCategoryManager {
|
|
|
|
public:
|
|
|
|
IncludeCategoryManager(const FormatStyle &Style, StringRef FileName)
|
|
|
|
: Style(Style), FileName(FileName) {
|
|
|
|
FileStem = llvm::sys::path::stem(FileName);
|
|
|
|
for (const auto &Category : Style.IncludeCategories)
|
|
|
|
CategoryRegexs.emplace_back(Category.Regex);
|
|
|
|
IsMainFile = FileName.endswith(".c") || FileName.endswith(".cc") ||
|
|
|
|
FileName.endswith(".cpp") || FileName.endswith(".c++") ||
|
|
|
|
FileName.endswith(".cxx") || FileName.endswith(".m") ||
|
|
|
|
FileName.endswith(".mm");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns the priority of the category which \p IncludeName belongs to.
|
|
|
|
// If \p CheckMainHeader is true and \p IncludeName is a main header, returns
|
|
|
|
// 0. Otherwise, returns the priority of the matching category or INT_MAX.
|
|
|
|
int getIncludePriority(StringRef IncludeName, bool CheckMainHeader) {
|
|
|
|
int Ret = INT_MAX;
|
|
|
|
for (unsigned i = 0, e = CategoryRegexs.size(); i != e; ++i)
|
|
|
|
if (CategoryRegexs[i].match(IncludeName)) {
|
|
|
|
Ret = Style.IncludeCategories[i].Priority;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (CheckMainHeader && IsMainFile && Ret > 0 && isMainHeader(IncludeName))
|
|
|
|
Ret = 0;
|
|
|
|
return Ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
bool isMainHeader(StringRef IncludeName) const {
|
|
|
|
if (!IncludeName.startswith("\""))
|
|
|
|
return false;
|
|
|
|
StringRef HeaderStem =
|
|
|
|
llvm::sys::path::stem(IncludeName.drop_front(1).drop_back(1));
|
|
|
|
if (FileStem.startswith(HeaderStem)) {
|
|
|
|
llvm::Regex MainIncludeRegex(
|
|
|
|
(HeaderStem + Style.IncludeIsMainRegex).str());
|
|
|
|
if (MainIncludeRegex.match(FileStem))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
const FormatStyle &Style;
|
|
|
|
bool IsMainFile;
|
|
|
|
StringRef FileName;
|
|
|
|
StringRef FileStem;
|
|
|
|
SmallVector<llvm::Regex, 4> CategoryRegexs;
|
|
|
|
};
|
|
|
|
|
|
|
|
const char IncludeRegexPattern[] =
|
|
|
|
R"(^[\t\ ]*#[\t\ ]*(import|include)[^"<]*(["<][^">]*[">]))";
|
|
|
|
|
|
|
|
} // anonymous namespace
|
|
|
|
|
2016-05-20 19:24:24 +08:00
|
|
|
tooling::Replacements sortCppIncludes(const FormatStyle &Style, StringRef Code,
|
|
|
|
ArrayRef<tooling::Range> Ranges,
|
|
|
|
StringRef FileName,
|
|
|
|
tooling::Replacements &Replaces,
|
|
|
|
unsigned *Cursor) {
|
2015-09-23 16:30:47 +08:00
|
|
|
unsigned Prev = 0;
|
|
|
|
unsigned SearchFrom = 0;
|
2016-05-31 21:34:20 +08:00
|
|
|
llvm::Regex IncludeRegex(IncludeRegexPattern);
|
2015-09-23 16:30:47 +08:00
|
|
|
SmallVector<StringRef, 4> Matches;
|
|
|
|
SmallVector<IncludeDirective, 16> IncludesInBlock;
|
2015-09-29 15:53:08 +08:00
|
|
|
|
|
|
|
// In compiled files, consider the first #include to be the main #include of
|
|
|
|
// the file if it is not a system #include. This ensures that the header
|
|
|
|
// doesn't have hidden dependencies
|
|
|
|
// (http://llvm.org/docs/CodingStandards.html#include-style).
|
|
|
|
//
|
|
|
|
// FIXME: Do some sanity checking, e.g. edit distance of the base name, to fix
|
|
|
|
// cases where the first #include is unlikely to be the main header.
|
2016-05-31 21:34:20 +08:00
|
|
|
IncludeCategoryManager Categories(Style, FileName);
|
2015-12-21 21:40:49 +08:00
|
|
|
bool FirstIncludeBlock = true;
|
2015-12-22 01:28:24 +08:00
|
|
|
bool MainIncludeFound = false;
|
2015-11-21 17:17:08 +08:00
|
|
|
bool FormattingOff = false;
|
|
|
|
|
2015-09-23 16:30:47 +08:00
|
|
|
for (;;) {
|
|
|
|
auto Pos = Code.find('\n', SearchFrom);
|
|
|
|
StringRef Line =
|
|
|
|
Code.substr(Prev, (Pos != StringRef::npos ? Pos : Code.size()) - Prev);
|
2015-11-21 17:17:08 +08:00
|
|
|
|
|
|
|
StringRef Trimmed = Line.trim();
|
|
|
|
if (Trimmed == "// clang-format off")
|
|
|
|
FormattingOff = true;
|
|
|
|
else if (Trimmed == "// clang-format on")
|
|
|
|
FormattingOff = false;
|
|
|
|
|
|
|
|
if (!FormattingOff && !Line.endswith("\\")) {
|
2015-09-23 16:30:47 +08:00
|
|
|
if (IncludeRegex.match(Line, &Matches)) {
|
2015-10-22 01:13:45 +08:00
|
|
|
StringRef IncludeName = Matches[2];
|
2016-05-31 21:34:20 +08:00
|
|
|
int Category = Categories.getIncludePriority(
|
|
|
|
IncludeName,
|
|
|
|
/*CheckMainHeader=*/!MainIncludeFound && FirstIncludeBlock);
|
|
|
|
if (Category == 0)
|
|
|
|
MainIncludeFound = true;
|
2015-10-22 01:13:45 +08:00
|
|
|
IncludesInBlock.push_back({IncludeName, Line, Prev, Category});
|
2015-09-23 16:30:47 +08:00
|
|
|
} else if (!IncludesInBlock.empty()) {
|
2016-05-20 19:24:24 +08:00
|
|
|
sortCppIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces,
|
|
|
|
Cursor);
|
2015-09-23 16:30:47 +08:00
|
|
|
IncludesInBlock.clear();
|
2015-12-21 21:40:49 +08:00
|
|
|
FirstIncludeBlock = false;
|
2015-09-23 16:30:47 +08:00
|
|
|
}
|
|
|
|
Prev = Pos + 1;
|
|
|
|
}
|
|
|
|
if (Pos == StringRef::npos || Pos + 1 == Code.size())
|
|
|
|
break;
|
|
|
|
SearchFrom = Pos + 1;
|
|
|
|
}
|
|
|
|
if (!IncludesInBlock.empty())
|
2016-05-20 19:24:24 +08:00
|
|
|
sortCppIncludes(Style, IncludesInBlock, Ranges, FileName, Replaces, Cursor);
|
|
|
|
return Replaces;
|
|
|
|
}
|
|
|
|
|
2017-01-27 17:09:11 +08:00
|
|
|
bool isMpegTS(StringRef Code) {
|
|
|
|
// MPEG transport streams use the ".ts" file extension. clang-format should
|
|
|
|
// not attempt to format those. MPEG TS' frame format starts with 0x47 every
|
|
|
|
// 189 bytes - detect that and return.
|
|
|
|
return Code.size() > 188 && Code[0] == 0x47 && Code[188] == 0x47;
|
|
|
|
}
|
|
|
|
|
2016-05-20 19:24:24 +08:00
|
|
|
tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code,
|
|
|
|
ArrayRef<tooling::Range> Ranges,
|
|
|
|
StringRef FileName, unsigned *Cursor) {
|
|
|
|
tooling::Replacements Replaces;
|
|
|
|
if (!Style.SortIncludes)
|
|
|
|
return Replaces;
|
2017-01-27 17:09:11 +08:00
|
|
|
if (Style.Language == FormatStyle::LanguageKind::LK_JavaScript &&
|
|
|
|
isMpegTS(Code))
|
|
|
|
return Replaces;
|
2016-05-20 19:24:24 +08:00
|
|
|
if (Style.Language == FormatStyle::LanguageKind::LK_JavaScript)
|
|
|
|
return sortJavaScriptImports(Style, Code, Ranges, FileName);
|
|
|
|
sortCppIncludes(Style, Code, Ranges, FileName, Replaces, Cursor);
|
2015-09-23 16:30:47 +08:00
|
|
|
return Replaces;
|
|
|
|
}
|
|
|
|
|
2016-04-25 23:09:22 +08:00
|
|
|
template <typename T>
|
2016-07-11 21:53:12 +08:00
|
|
|
static llvm::Expected<tooling::Replacements>
|
2016-04-25 23:09:22 +08:00
|
|
|
processReplacements(T ProcessFunc, StringRef Code,
|
|
|
|
const tooling::Replacements &Replaces,
|
|
|
|
const FormatStyle &Style) {
|
2016-03-01 20:37:30 +08:00
|
|
|
if (Replaces.empty())
|
|
|
|
return tooling::Replacements();
|
|
|
|
|
2016-07-11 21:53:12 +08:00
|
|
|
auto NewCode = applyAllReplacements(Code, Replaces);
|
|
|
|
if (!NewCode)
|
|
|
|
return NewCode.takeError();
|
2016-08-01 18:16:37 +08:00
|
|
|
std::vector<tooling::Range> ChangedRanges = Replaces.getAffectedRanges();
|
2016-03-01 20:37:30 +08:00
|
|
|
StringRef FileName = Replaces.begin()->getFilePath();
|
2016-04-25 23:09:22 +08:00
|
|
|
|
2016-03-01 20:37:30 +08:00
|
|
|
tooling::Replacements FormatReplaces =
|
2016-07-11 21:53:12 +08:00
|
|
|
ProcessFunc(Style, *NewCode, ChangedRanges, FileName);
|
2016-03-01 20:37:30 +08:00
|
|
|
|
2016-08-01 18:16:37 +08:00
|
|
|
return Replaces.merge(FormatReplaces);
|
2016-04-25 23:09:22 +08:00
|
|
|
}
|
2016-03-24 18:21:00 +08:00
|
|
|
|
2016-07-11 21:53:12 +08:00
|
|
|
llvm::Expected<tooling::Replacements>
|
|
|
|
formatReplacements(StringRef Code, const tooling::Replacements &Replaces,
|
|
|
|
const FormatStyle &Style) {
|
2016-04-25 23:09:22 +08:00
|
|
|
// We need to use lambda function here since there are two versions of
|
2016-05-18 21:43:48 +08:00
|
|
|
// `sortIncludes`.
|
|
|
|
auto SortIncludes = [](const FormatStyle &Style, StringRef Code,
|
|
|
|
std::vector<tooling::Range> Ranges,
|
|
|
|
StringRef FileName) -> tooling::Replacements {
|
|
|
|
return sortIncludes(Style, Code, Ranges, FileName);
|
|
|
|
};
|
2016-07-11 21:53:12 +08:00
|
|
|
auto SortedReplaces =
|
2016-05-18 21:43:48 +08:00
|
|
|
processReplacements(SortIncludes, Code, Replaces, Style);
|
2016-07-11 21:53:12 +08:00
|
|
|
if (!SortedReplaces)
|
|
|
|
return SortedReplaces.takeError();
|
2016-05-18 21:43:48 +08:00
|
|
|
|
|
|
|
// We need to use lambda function here since there are two versions of
|
2016-04-25 23:09:22 +08:00
|
|
|
// `reformat`.
|
|
|
|
auto Reformat = [](const FormatStyle &Style, StringRef Code,
|
|
|
|
std::vector<tooling::Range> Ranges,
|
|
|
|
StringRef FileName) -> tooling::Replacements {
|
|
|
|
return reformat(Style, Code, Ranges, FileName);
|
|
|
|
};
|
2016-07-11 21:53:12 +08:00
|
|
|
return processReplacements(Reformat, Code, *SortedReplaces, Style);
|
2016-03-01 20:37:30 +08:00
|
|
|
}
|
|
|
|
|
2016-05-31 21:34:20 +08:00
|
|
|
namespace {
|
|
|
|
|
|
|
|
inline bool isHeaderInsertion(const tooling::Replacement &Replace) {
|
2016-09-23 23:10:56 +08:00
|
|
|
return Replace.getOffset() == UINT_MAX && Replace.getLength() == 0 &&
|
2016-05-31 21:34:20 +08:00
|
|
|
llvm::Regex(IncludeRegexPattern).match(Replace.getReplacementText());
|
|
|
|
}
|
|
|
|
|
2016-09-23 23:10:56 +08:00
|
|
|
inline bool isHeaderDeletion(const tooling::Replacement &Replace) {
|
|
|
|
return Replace.getOffset() == UINT_MAX && Replace.getLength() == 1;
|
|
|
|
}
|
|
|
|
|
2016-12-02 19:01:43 +08:00
|
|
|
// Returns the offset after skipping a sequence of tokens, matched by \p
|
|
|
|
// GetOffsetAfterSequence, from the start of the code.
|
|
|
|
// \p GetOffsetAfterSequence should be a function that matches a sequence of
|
|
|
|
// tokens and returns an offset after the sequence.
|
|
|
|
unsigned getOffsetAfterTokenSequence(
|
|
|
|
StringRef FileName, StringRef Code, const FormatStyle &Style,
|
2017-03-08 17:13:25 +08:00
|
|
|
llvm::function_ref<unsigned(const SourceManager &, Lexer &, Token &)>
|
|
|
|
GetOffsetAfterSequence) {
|
2016-12-02 19:01:43 +08:00
|
|
|
std::unique_ptr<Environment> Env =
|
|
|
|
Environment::CreateVirtualEnvironment(Code, FileName, /*Ranges=*/{});
|
|
|
|
const SourceManager &SourceMgr = Env->getSourceManager();
|
|
|
|
Lexer Lex(Env->getFileID(), SourceMgr.getBuffer(Env->getFileID()), SourceMgr,
|
|
|
|
getFormattingLangOpts(Style));
|
|
|
|
Token Tok;
|
|
|
|
// Get the first token.
|
|
|
|
Lex.LexFromRawLexer(Tok);
|
2017-03-08 17:13:25 +08:00
|
|
|
return GetOffsetAfterSequence(SourceMgr, Lex, Tok);
|
2016-06-06 19:00:13 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Check if a sequence of tokens is like "#<Name> <raw_identifier>". If it is,
|
|
|
|
// \p Tok will be the token after this directive; otherwise, it can be any token
|
|
|
|
// after the given \p Tok (including \p Tok).
|
|
|
|
bool checkAndConsumeDirectiveWithName(Lexer &Lex, StringRef Name, Token &Tok) {
|
|
|
|
bool Matched = Tok.is(tok::hash) && !Lex.LexFromRawLexer(Tok) &&
|
|
|
|
Tok.is(tok::raw_identifier) &&
|
|
|
|
Tok.getRawIdentifier() == Name && !Lex.LexFromRawLexer(Tok) &&
|
2016-12-19 18:41:05 +08:00
|
|
|
Tok.is(tok::raw_identifier);
|
2016-06-06 19:00:13 +08:00
|
|
|
if (Matched)
|
|
|
|
Lex.LexFromRawLexer(Tok);
|
|
|
|
return Matched;
|
|
|
|
}
|
|
|
|
|
2016-12-02 19:01:43 +08:00
|
|
|
void skipComments(Lexer &Lex, Token &Tok) {
|
|
|
|
while (Tok.is(tok::comment))
|
|
|
|
if (Lex.LexFromRawLexer(Tok))
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns the offset after header guard directives and any comments
|
|
|
|
// before/after header guards. If no header guard presents in the code, this
|
|
|
|
// will returns the offset after skipping all comments from the start of the
|
|
|
|
// code.
|
2016-06-06 19:00:13 +08:00
|
|
|
unsigned getOffsetAfterHeaderGuardsAndComments(StringRef FileName,
|
|
|
|
StringRef Code,
|
2016-06-11 19:45:08 +08:00
|
|
|
const FormatStyle &Style) {
|
2016-12-02 19:01:43 +08:00
|
|
|
return getOffsetAfterTokenSequence(
|
|
|
|
FileName, Code, Style,
|
|
|
|
[](const SourceManager &SM, Lexer &Lex, Token Tok) {
|
|
|
|
skipComments(Lex, Tok);
|
|
|
|
unsigned InitialOffset = SM.getFileOffset(Tok.getLocation());
|
|
|
|
if (checkAndConsumeDirectiveWithName(Lex, "ifndef", Tok)) {
|
|
|
|
skipComments(Lex, Tok);
|
|
|
|
if (checkAndConsumeDirectiveWithName(Lex, "define", Tok))
|
|
|
|
return SM.getFileOffset(Tok.getLocation());
|
|
|
|
}
|
|
|
|
return InitialOffset;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if a sequence of tokens is like
|
|
|
|
// "#include ("header.h" | <header.h>)".
|
|
|
|
// If it is, \p Tok will be the token after this directive; otherwise, it can be
|
|
|
|
// any token after the given \p Tok (including \p Tok).
|
|
|
|
bool checkAndConsumeInclusiveDirective(Lexer &Lex, Token &Tok) {
|
|
|
|
auto Matched = [&]() {
|
|
|
|
Lex.LexFromRawLexer(Tok);
|
|
|
|
return true;
|
|
|
|
};
|
|
|
|
if (Tok.is(tok::hash) && !Lex.LexFromRawLexer(Tok) &&
|
|
|
|
Tok.is(tok::raw_identifier) && Tok.getRawIdentifier() == "include") {
|
|
|
|
if (Lex.LexFromRawLexer(Tok))
|
|
|
|
return false;
|
|
|
|
if (Tok.is(tok::string_literal))
|
|
|
|
return Matched();
|
|
|
|
if (Tok.is(tok::less)) {
|
|
|
|
while (!Lex.LexFromRawLexer(Tok) && Tok.isNot(tok::greater)) {
|
|
|
|
}
|
|
|
|
if (Tok.is(tok::greater))
|
|
|
|
return Matched();
|
|
|
|
}
|
2016-06-06 19:00:13 +08:00
|
|
|
}
|
2016-12-02 19:01:43 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns the offset of the last #include directive after which a new
|
|
|
|
// #include can be inserted. This ignores #include's after the #include block(s)
|
|
|
|
// in the beginning of a file to avoid inserting headers into code sections
|
|
|
|
// where new #include's should not be added by default.
|
|
|
|
// These code sections include:
|
|
|
|
// - raw string literals (containing #include).
|
|
|
|
// - #if blocks.
|
|
|
|
// - Special #include's among declarations (e.g. functions).
|
|
|
|
//
|
|
|
|
// If no #include after which a new #include can be inserted, this returns the
|
|
|
|
// offset after skipping all comments from the start of the code.
|
|
|
|
// Inserting after an #include is not allowed if it comes after code that is not
|
|
|
|
// #include (e.g. pre-processing directive that is not #include, declarations).
|
|
|
|
unsigned getMaxHeaderInsertionOffset(StringRef FileName, StringRef Code,
|
|
|
|
const FormatStyle &Style) {
|
|
|
|
return getOffsetAfterTokenSequence(
|
|
|
|
FileName, Code, Style,
|
|
|
|
[](const SourceManager &SM, Lexer &Lex, Token Tok) {
|
|
|
|
skipComments(Lex, Tok);
|
|
|
|
unsigned MaxOffset = SM.getFileOffset(Tok.getLocation());
|
|
|
|
while (checkAndConsumeInclusiveDirective(Lex, Tok))
|
|
|
|
MaxOffset = SM.getFileOffset(Tok.getLocation());
|
|
|
|
return MaxOffset;
|
|
|
|
});
|
2016-06-06 19:00:13 +08:00
|
|
|
}
|
|
|
|
|
2016-09-23 23:10:56 +08:00
|
|
|
bool isDeletedHeader(llvm::StringRef HeaderName,
|
2016-11-24 23:42:29 +08:00
|
|
|
const std::set<llvm::StringRef> &HeadersToDelete) {
|
|
|
|
return HeadersToDelete.count(HeaderName) ||
|
|
|
|
HeadersToDelete.count(HeaderName.trim("\"<>"));
|
2016-09-23 23:10:56 +08:00
|
|
|
}
|
|
|
|
|
2016-05-31 21:34:20 +08:00
|
|
|
// FIXME: insert empty lines between newly created blocks.
|
|
|
|
tooling::Replacements
|
|
|
|
fixCppIncludeInsertions(StringRef Code, const tooling::Replacements &Replaces,
|
|
|
|
const FormatStyle &Style) {
|
2017-03-31 21:30:24 +08:00
|
|
|
if (!Style.isCpp())
|
2016-05-31 21:34:20 +08:00
|
|
|
return Replaces;
|
|
|
|
|
|
|
|
tooling::Replacements HeaderInsertions;
|
2016-09-23 23:10:56 +08:00
|
|
|
std::set<llvm::StringRef> HeadersToDelete;
|
2016-08-01 18:16:37 +08:00
|
|
|
tooling::Replacements Result;
|
2016-05-31 21:34:20 +08:00
|
|
|
for (const auto &R : Replaces) {
|
2016-08-01 18:16:37 +08:00
|
|
|
if (isHeaderInsertion(R)) {
|
|
|
|
// Replacements from \p Replaces must be conflict-free already, so we can
|
|
|
|
// simply consume the error.
|
|
|
|
llvm::consumeError(HeaderInsertions.add(R));
|
2016-09-23 23:10:56 +08:00
|
|
|
} else if (isHeaderDeletion(R)) {
|
|
|
|
HeadersToDelete.insert(R.getReplacementText());
|
2016-08-01 18:16:37 +08:00
|
|
|
} else if (R.getOffset() == UINT_MAX) {
|
2016-05-31 21:34:20 +08:00
|
|
|
llvm::errs() << "Insertions other than header #include insertion are "
|
|
|
|
"not supported! "
|
|
|
|
<< R.getReplacementText() << "\n";
|
2016-08-01 18:16:37 +08:00
|
|
|
} else {
|
|
|
|
llvm::consumeError(Result.add(R));
|
|
|
|
}
|
2016-05-31 21:34:20 +08:00
|
|
|
}
|
2016-09-23 23:10:56 +08:00
|
|
|
if (HeaderInsertions.empty() && HeadersToDelete.empty())
|
2016-05-31 21:34:20 +08:00
|
|
|
return Replaces;
|
|
|
|
|
|
|
|
llvm::Regex IncludeRegex(IncludeRegexPattern);
|
|
|
|
llvm::Regex DefineRegex(R"(^[\t\ ]*#[\t\ ]*define[\t\ ]*[^\\]*$)");
|
|
|
|
SmallVector<StringRef, 4> Matches;
|
|
|
|
|
|
|
|
StringRef FileName = Replaces.begin()->getFilePath();
|
|
|
|
IncludeCategoryManager Categories(Style, FileName);
|
|
|
|
|
|
|
|
// Record the offset of the end of the last include in each category.
|
|
|
|
std::map<int, int> CategoryEndOffsets;
|
|
|
|
// All possible priorities.
|
|
|
|
// Add 0 for main header and INT_MAX for headers that are not in any category.
|
|
|
|
std::set<int> Priorities = {0, INT_MAX};
|
|
|
|
for (const auto &Category : Style.IncludeCategories)
|
|
|
|
Priorities.insert(Category.Priority);
|
|
|
|
int FirstIncludeOffset = -1;
|
2016-06-06 19:00:13 +08:00
|
|
|
// All new headers should be inserted after this offset.
|
|
|
|
unsigned MinInsertOffset =
|
|
|
|
getOffsetAfterHeaderGuardsAndComments(FileName, Code, Style);
|
2016-06-03 20:52:59 +08:00
|
|
|
StringRef TrimmedCode = Code.drop_front(MinInsertOffset);
|
2016-12-09 19:45:50 +08:00
|
|
|
// Max insertion offset in the original code.
|
2016-12-02 19:01:43 +08:00
|
|
|
unsigned MaxInsertOffset =
|
2016-12-09 19:45:50 +08:00
|
|
|
MinInsertOffset +
|
2016-12-02 19:01:43 +08:00
|
|
|
getMaxHeaderInsertionOffset(FileName, TrimmedCode, Style);
|
2016-05-31 21:34:20 +08:00
|
|
|
SmallVector<StringRef, 32> Lines;
|
2016-06-03 20:52:59 +08:00
|
|
|
TrimmedCode.split(Lines, '\n');
|
2016-06-06 19:00:13 +08:00
|
|
|
unsigned Offset = MinInsertOffset;
|
|
|
|
unsigned NextLineOffset;
|
2016-06-14 22:09:21 +08:00
|
|
|
std::set<StringRef> ExistingIncludes;
|
2016-05-31 21:34:20 +08:00
|
|
|
for (auto Line : Lines) {
|
2016-06-06 19:00:13 +08:00
|
|
|
NextLineOffset = std::min(Code.size(), Offset + Line.size() + 1);
|
2016-05-31 21:34:20 +08:00
|
|
|
if (IncludeRegex.match(Line, &Matches)) {
|
2016-09-23 23:10:56 +08:00
|
|
|
// The header name with quotes or angle brackets.
|
2016-05-31 21:34:20 +08:00
|
|
|
StringRef IncludeName = Matches[2];
|
2016-06-14 22:09:21 +08:00
|
|
|
ExistingIncludes.insert(IncludeName);
|
2016-12-02 19:01:43 +08:00
|
|
|
// Only record the offset of current #include if we can insert after it.
|
|
|
|
if (Offset <= MaxInsertOffset) {
|
|
|
|
int Category = Categories.getIncludePriority(
|
|
|
|
IncludeName, /*CheckMainHeader=*/FirstIncludeOffset < 0);
|
|
|
|
CategoryEndOffsets[Category] = NextLineOffset;
|
|
|
|
if (FirstIncludeOffset < 0)
|
|
|
|
FirstIncludeOffset = Offset;
|
|
|
|
}
|
2016-09-23 23:10:56 +08:00
|
|
|
if (isDeletedHeader(IncludeName, HeadersToDelete)) {
|
|
|
|
// If this is the last line without trailing newline, we need to make
|
|
|
|
// sure we don't delete across the file boundary.
|
|
|
|
unsigned Length = std::min(Line.size() + 1, Code.size() - Offset);
|
|
|
|
llvm::Error Err =
|
|
|
|
Result.add(tooling::Replacement(FileName, Offset, Length, ""));
|
|
|
|
if (Err) {
|
|
|
|
// Ignore the deletion on conflict.
|
|
|
|
llvm::errs() << "Failed to add header deletion replacement for "
|
|
|
|
<< IncludeName << ": " << llvm::toString(std::move(Err))
|
|
|
|
<< "\n";
|
|
|
|
}
|
|
|
|
}
|
2016-05-31 21:34:20 +08:00
|
|
|
}
|
2016-06-06 19:00:13 +08:00
|
|
|
Offset = NextLineOffset;
|
2016-05-31 21:34:20 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Populate CategoryEndOfssets:
|
|
|
|
// - Ensure that CategoryEndOffset[Highest] is always populated.
|
|
|
|
// - If CategoryEndOffset[Priority] isn't set, use the next higher value that
|
|
|
|
// is set, up to CategoryEndOffset[Highest].
|
|
|
|
auto Highest = Priorities.begin();
|
|
|
|
if (CategoryEndOffsets.find(*Highest) == CategoryEndOffsets.end()) {
|
|
|
|
if (FirstIncludeOffset >= 0)
|
|
|
|
CategoryEndOffsets[*Highest] = FirstIncludeOffset;
|
|
|
|
else
|
2016-06-03 20:52:59 +08:00
|
|
|
CategoryEndOffsets[*Highest] = MinInsertOffset;
|
2016-05-31 21:34:20 +08:00
|
|
|
}
|
|
|
|
// By this point, CategoryEndOffset[Highest] is always set appropriately:
|
|
|
|
// - to an appropriate location before/after existing #includes, or
|
|
|
|
// - to right after the header guard, or
|
|
|
|
// - to the beginning of the file.
|
|
|
|
for (auto I = ++Priorities.begin(), E = Priorities.end(); I != E; ++I)
|
|
|
|
if (CategoryEndOffsets.find(*I) == CategoryEndOffsets.end())
|
|
|
|
CategoryEndOffsets[*I] = CategoryEndOffsets[*std::prev(I)];
|
|
|
|
|
2016-10-05 23:42:19 +08:00
|
|
|
bool NeedNewLineAtEnd = !Code.empty() && Code.back() != '\n';
|
2016-05-31 21:34:20 +08:00
|
|
|
for (const auto &R : HeaderInsertions) {
|
|
|
|
auto IncludeDirective = R.getReplacementText();
|
|
|
|
bool Matched = IncludeRegex.match(IncludeDirective, &Matches);
|
|
|
|
assert(Matched && "Header insertion replacement must have replacement text "
|
|
|
|
"'#include ...'");
|
2016-05-31 22:14:42 +08:00
|
|
|
(void)Matched;
|
2016-05-31 21:34:20 +08:00
|
|
|
auto IncludeName = Matches[2];
|
2016-06-14 22:09:21 +08:00
|
|
|
if (ExistingIncludes.find(IncludeName) != ExistingIncludes.end()) {
|
|
|
|
DEBUG(llvm::dbgs() << "Skip adding existing include : " << IncludeName
|
|
|
|
<< "\n");
|
|
|
|
continue;
|
|
|
|
}
|
2016-05-31 21:34:20 +08:00
|
|
|
int Category =
|
|
|
|
Categories.getIncludePriority(IncludeName, /*CheckMainHeader=*/true);
|
|
|
|
Offset = CategoryEndOffsets[Category];
|
|
|
|
std::string NewInclude = !IncludeDirective.endswith("\n")
|
|
|
|
? (IncludeDirective + "\n").str()
|
|
|
|
: IncludeDirective.str();
|
2016-10-05 23:42:19 +08:00
|
|
|
// When inserting headers at end of the code, also append '\n' to the code
|
|
|
|
// if it does not end with '\n'.
|
|
|
|
if (NeedNewLineAtEnd && Offset == Code.size()) {
|
|
|
|
NewInclude = "\n" + NewInclude;
|
|
|
|
NeedNewLineAtEnd = false;
|
|
|
|
}
|
2016-08-01 18:16:37 +08:00
|
|
|
auto NewReplace = tooling::Replacement(FileName, Offset, 0, NewInclude);
|
|
|
|
auto Err = Result.add(NewReplace);
|
|
|
|
if (Err) {
|
|
|
|
llvm::consumeError(std::move(Err));
|
2016-10-05 23:42:19 +08:00
|
|
|
unsigned NewOffset = Result.getShiftedCodePosition(Offset);
|
|
|
|
NewReplace = tooling::Replacement(FileName, NewOffset, 0, NewInclude);
|
2016-08-01 18:16:37 +08:00
|
|
|
Result = Result.merge(tooling::Replacements(NewReplace));
|
|
|
|
}
|
2016-05-31 21:34:20 +08:00
|
|
|
}
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
} // anonymous namespace
|
|
|
|
|
2016-07-11 21:53:12 +08:00
|
|
|
llvm::Expected<tooling::Replacements>
|
2016-04-25 23:09:22 +08:00
|
|
|
cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces,
|
|
|
|
const FormatStyle &Style) {
|
|
|
|
// We need to use lambda function here since there are two versions of
|
|
|
|
// `cleanup`.
|
|
|
|
auto Cleanup = [](const FormatStyle &Style, StringRef Code,
|
|
|
|
std::vector<tooling::Range> Ranges,
|
|
|
|
StringRef FileName) -> tooling::Replacements {
|
|
|
|
return cleanup(Style, Code, Ranges, FileName);
|
|
|
|
};
|
2016-05-31 21:34:20 +08:00
|
|
|
// Make header insertion replacements insert new headers into correct blocks.
|
|
|
|
tooling::Replacements NewReplaces =
|
|
|
|
fixCppIncludeInsertions(Code, Replaces, Style);
|
|
|
|
return processReplacements(Cleanup, Code, NewReplaces, Style);
|
2016-04-25 23:09:22 +08:00
|
|
|
}
|
|
|
|
|
2013-05-16 18:40:07 +08:00
|
|
|
tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
|
2014-10-04 02:52:48 +08:00
|
|
|
ArrayRef<tooling::Range> Ranges,
|
2017-04-21 22:35:20 +08:00
|
|
|
StringRef FileName,
|
|
|
|
FormattingAttemptStatus *Status) {
|
2016-04-25 23:09:22 +08:00
|
|
|
FormatStyle Expanded = expandPresets(Style);
|
|
|
|
if (Expanded.DisableFormat)
|
2014-09-09 22:37:39 +08:00
|
|
|
return tooling::Replacements();
|
2017-01-27 17:09:11 +08:00
|
|
|
if (Expanded.Language == FormatStyle::LK_JavaScript && isMpegTS(Code))
|
|
|
|
return tooling::Replacements();
|
2016-09-08 06:48:53 +08:00
|
|
|
auto Env = Environment::CreateVirtualEnvironment(Code, FileName, Ranges);
|
|
|
|
|
2017-03-01 23:35:39 +08:00
|
|
|
auto reformatAfterApplying = [&] (TokenAnalyzer& Fixer) {
|
|
|
|
tooling::Replacements Fixes = Fixer.process();
|
|
|
|
if (!Fixes.empty()) {
|
|
|
|
auto NewCode = applyAllReplacements(Code, Fixes);
|
2016-09-08 06:48:53 +08:00
|
|
|
if (NewCode) {
|
|
|
|
auto NewEnv = Environment::CreateVirtualEnvironment(
|
|
|
|
*NewCode, FileName,
|
2017-03-01 23:35:39 +08:00
|
|
|
tooling::calculateRangesAfterReplacements(Fixes, Ranges));
|
2017-04-21 22:35:20 +08:00
|
|
|
Formatter Format(*NewEnv, Expanded, Status);
|
2017-03-01 23:35:39 +08:00
|
|
|
return Fixes.merge(Format.process());
|
2016-09-08 06:48:53 +08:00
|
|
|
}
|
|
|
|
}
|
2017-04-21 22:35:20 +08:00
|
|
|
Formatter Format(*Env, Expanded, Status);
|
2017-03-01 23:35:39 +08:00
|
|
|
return Format.process();
|
|
|
|
};
|
|
|
|
|
|
|
|
if (Style.Language == FormatStyle::LK_Cpp &&
|
|
|
|
Style.FixNamespaceComments) {
|
|
|
|
NamespaceEndCommentsFixer CommentsFixer(*Env, Expanded);
|
|
|
|
return reformatAfterApplying(CommentsFixer);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Style.Language == FormatStyle::LK_JavaScript &&
|
|
|
|
Style.JavaScriptQuotes != FormatStyle::JSQS_Leave) {
|
|
|
|
JavaScriptRequoter Requoter(*Env, Expanded);
|
|
|
|
return reformatAfterApplying(Requoter);
|
2016-09-08 06:48:53 +08:00
|
|
|
}
|
|
|
|
|
2017-04-21 22:35:20 +08:00
|
|
|
Formatter Format(*Env, Expanded, Status);
|
2016-04-25 23:09:22 +08:00
|
|
|
return Format.process();
|
|
|
|
}
|
|
|
|
|
|
|
|
tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code,
|
|
|
|
ArrayRef<tooling::Range> Ranges,
|
|
|
|
StringRef FileName) {
|
|
|
|
std::unique_ptr<Environment> Env =
|
2016-04-28 15:52:03 +08:00
|
|
|
Environment::CreateVirtualEnvironment(Code, FileName, Ranges);
|
|
|
|
Cleaner Clean(*Env, Style);
|
2016-04-25 23:09:22 +08:00
|
|
|
return Clean.process();
|
2013-05-16 18:40:07 +08:00
|
|
|
}
|
|
|
|
|
2017-04-21 22:35:20 +08:00
|
|
|
tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
|
|
|
|
ArrayRef<tooling::Range> Ranges,
|
|
|
|
StringRef FileName, bool *IncompleteFormat) {
|
|
|
|
FormattingAttemptStatus Status;
|
|
|
|
auto Result = reformat(Style, Code, Ranges, FileName, &Status);
|
|
|
|
if (!Status.FormatComplete)
|
|
|
|
*IncompleteFormat = true;
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
2017-02-27 21:28:36 +08:00
|
|
|
tooling::Replacements fixNamespaceEndComments(const FormatStyle &Style,
|
|
|
|
StringRef Code,
|
|
|
|
ArrayRef<tooling::Range> Ranges,
|
|
|
|
StringRef FileName) {
|
|
|
|
std::unique_ptr<Environment> Env =
|
|
|
|
Environment::CreateVirtualEnvironment(Code, FileName, Ranges);
|
|
|
|
NamespaceEndCommentsFixer Fix(*Env, Style);
|
|
|
|
return Fix.process();
|
|
|
|
}
|
|
|
|
|
2014-09-05 02:23:42 +08:00
|
|
|
LangOptions getFormattingLangOpts(const FormatStyle &Style) {
|
2013-01-10 21:08:12 +08:00
|
|
|
LangOptions LangOpts;
|
|
|
|
LangOpts.CPlusPlus = 1;
|
2014-09-05 02:23:42 +08:00
|
|
|
LangOpts.CPlusPlus11 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
|
|
|
|
LangOpts.CPlusPlus14 = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
|
2017-04-06 02:10:42 +08:00
|
|
|
LangOpts.CPlusPlus1z = Style.Standard == FormatStyle::LS_Cpp03 ? 0 : 1;
|
2013-03-22 18:01:29 +08:00
|
|
|
LangOpts.LineComment = 1;
|
2017-03-31 21:30:24 +08:00
|
|
|
bool AlternativeOperators = Style.isCpp();
|
2014-11-14 17:02:28 +08:00
|
|
|
LangOpts.CXXOperatorNames = AlternativeOperators ? 1 : 0;
|
2013-01-10 21:08:12 +08:00
|
|
|
LangOpts.Bool = 1;
|
|
|
|
LangOpts.ObjC1 = 1;
|
|
|
|
LangOpts.ObjC2 = 1;
|
2016-04-25 23:09:22 +08:00
|
|
|
LangOpts.MicrosoftExt = 1; // To get kw___try, kw___finally.
|
2015-10-05 01:51:05 +08:00
|
|
|
LangOpts.DeclSpecKeyword = 1; // To get __declspec.
|
2013-01-10 21:08:12 +08:00
|
|
|
return LangOpts;
|
|
|
|
}
|
|
|
|
|
2013-09-30 21:31:48 +08:00
|
|
|
const char *StyleOptionHelpDescription =
|
|
|
|
"Coding style, currently supports:\n"
|
|
|
|
" LLVM, Google, Chromium, Mozilla, WebKit.\n"
|
|
|
|
"Use -style=file to load style configuration from\n"
|
|
|
|
".clang-format file located in one of the parent\n"
|
|
|
|
"directories of the source file (or current\n"
|
|
|
|
"directory for stdin).\n"
|
|
|
|
"Use -style=\"{key: value, ...}\" to set specific\n"
|
|
|
|
"parameters, e.g.:\n"
|
|
|
|
" -style=\"{BasedOnStyle: llvm, IndentWidth: 8}\"";
|
|
|
|
|
2013-12-10 19:28:13 +08:00
|
|
|
static FormatStyle::LanguageKind getLanguageByFileName(StringRef FileName) {
|
2015-12-25 16:53:31 +08:00
|
|
|
if (FileName.endswith(".java"))
|
2014-09-15 19:21:46 +08:00
|
|
|
return FormatStyle::LK_Java;
|
2015-12-25 16:53:31 +08:00
|
|
|
if (FileName.endswith_lower(".js") || FileName.endswith_lower(".ts"))
|
|
|
|
return FormatStyle::LK_JavaScript; // JavaScript or TypeScript.
|
2016-12-12 20:42:29 +08:00
|
|
|
if (FileName.endswith(".m") || FileName.endswith(".mm"))
|
|
|
|
return FormatStyle::LK_ObjC;
|
2015-12-25 16:53:31 +08:00
|
|
|
if (FileName.endswith_lower(".proto") ||
|
|
|
|
FileName.endswith_lower(".protodevel"))
|
2014-01-19 17:04:08 +08:00
|
|
|
return FormatStyle::LK_Proto;
|
2015-12-25 16:53:31 +08:00
|
|
|
if (FileName.endswith_lower(".td"))
|
|
|
|
return FormatStyle::LK_TableGen;
|
2013-12-10 19:28:13 +08:00
|
|
|
return FormatStyle::LK_Cpp;
|
2013-11-29 23:19:43 +08:00
|
|
|
}
|
|
|
|
|
2017-01-17 08:12:27 +08:00
|
|
|
llvm::Expected<FormatStyle> getStyle(StringRef StyleName, StringRef FileName,
|
2017-01-20 09:22:42 +08:00
|
|
|
StringRef FallbackStyleName,
|
|
|
|
StringRef Code, vfs::FileSystem *FS) {
|
2016-03-24 21:22:42 +08:00
|
|
|
if (!FS) {
|
|
|
|
FS = vfs::getRealFileSystem().get();
|
|
|
|
}
|
2013-12-10 19:28:13 +08:00
|
|
|
FormatStyle Style = getLLVMStyle();
|
|
|
|
Style.Language = getLanguageByFileName(FileName);
|
2016-12-12 20:42:29 +08:00
|
|
|
|
|
|
|
// This is a very crude detection of whether a header contains ObjC code that
|
|
|
|
// should be improved over time and probably be done on tokens, not one the
|
|
|
|
// bare content of the file.
|
|
|
|
if (Style.Language == FormatStyle::LK_Cpp && FileName.endswith(".h") &&
|
|
|
|
(Code.contains("\n- (") || Code.contains("\n+ (")))
|
|
|
|
Style.Language = FormatStyle::LK_ObjC;
|
|
|
|
|
2017-01-20 09:22:42 +08:00
|
|
|
FormatStyle FallbackStyle = getNoStyle();
|
|
|
|
if (!getPredefinedStyle(FallbackStyleName, Style.Language, &FallbackStyle))
|
|
|
|
return make_string_error("Invalid fallback style \"" + FallbackStyleName);
|
2013-09-30 21:31:48 +08:00
|
|
|
|
|
|
|
if (StyleName.startswith("{")) {
|
|
|
|
// Parse YAML/JSON style from the command line.
|
2017-01-17 08:12:27 +08:00
|
|
|
if (std::error_code ec = parseConfiguration(StyleName, &Style))
|
|
|
|
return make_string_error("Error parsing -style: " + ec.message());
|
2013-09-30 21:31:48 +08:00
|
|
|
return Style;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!StyleName.equals_lower("file")) {
|
2013-12-10 19:28:13 +08:00
|
|
|
if (!getPredefinedStyle(StyleName, Style.Language, &Style))
|
2017-01-17 08:12:27 +08:00
|
|
|
return make_string_error("Invalid value for -style");
|
2013-09-30 21:31:48 +08:00
|
|
|
return Style;
|
|
|
|
}
|
|
|
|
|
2013-12-10 19:28:13 +08:00
|
|
|
// Look for .clang-format/_clang-format file in the file's parent directories.
|
2013-11-29 23:19:43 +08:00
|
|
|
SmallString<128> UnsuitableConfigFiles;
|
2013-09-30 21:31:48 +08:00
|
|
|
SmallString<128> Path(FileName);
|
2017-01-17 08:12:27 +08:00
|
|
|
if (std::error_code EC = FS->makeAbsolute(Path))
|
|
|
|
return make_string_error(EC.message());
|
2016-12-22 13:10:07 +08:00
|
|
|
|
2013-10-14 08:46:35 +08:00
|
|
|
for (StringRef Directory = Path; !Directory.empty();
|
2013-09-30 21:31:48 +08:00
|
|
|
Directory = llvm::sys::path::parent_path(Directory)) {
|
2016-03-24 21:22:42 +08:00
|
|
|
|
|
|
|
auto Status = FS->status(Directory);
|
|
|
|
if (!Status ||
|
|
|
|
Status->getType() != llvm::sys::fs::file_type::directory_file) {
|
2013-09-30 21:31:48 +08:00
|
|
|
continue;
|
2016-03-24 21:22:42 +08:00
|
|
|
}
|
|
|
|
|
2013-09-30 21:31:48 +08:00
|
|
|
SmallString<128> ConfigFile(Directory);
|
|
|
|
|
|
|
|
llvm::sys::path::append(ConfigFile, ".clang-format");
|
|
|
|
DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
|
2016-03-24 21:22:37 +08:00
|
|
|
|
2016-03-24 21:22:42 +08:00
|
|
|
Status = FS->status(ConfigFile.str());
|
2017-01-17 08:12:27 +08:00
|
|
|
bool FoundConfigFile =
|
2016-03-24 21:22:42 +08:00
|
|
|
Status && (Status->getType() == llvm::sys::fs::file_type::regular_file);
|
2017-01-17 08:12:27 +08:00
|
|
|
if (!FoundConfigFile) {
|
2013-09-30 21:31:48 +08:00
|
|
|
// Try _clang-format too, since dotfiles are not commonly used on Windows.
|
|
|
|
ConfigFile = Directory;
|
|
|
|
llvm::sys::path::append(ConfigFile, "_clang-format");
|
|
|
|
DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
|
2016-03-24 21:22:42 +08:00
|
|
|
Status = FS->status(ConfigFile.str());
|
2017-01-17 08:12:27 +08:00
|
|
|
FoundConfigFile = Status && (Status->getType() ==
|
|
|
|
llvm::sys::fs::file_type::regular_file);
|
2013-09-30 21:31:48 +08:00
|
|
|
}
|
|
|
|
|
2017-01-17 08:12:27 +08:00
|
|
|
if (FoundConfigFile) {
|
2014-07-07 01:43:24 +08:00
|
|
|
llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
|
2016-03-24 21:22:42 +08:00
|
|
|
FS->getBufferForFile(ConfigFile.str());
|
2017-01-17 08:12:27 +08:00
|
|
|
if (std::error_code EC = Text.getError())
|
|
|
|
return make_string_error(EC.message());
|
2014-07-07 01:43:24 +08:00
|
|
|
if (std::error_code ec =
|
|
|
|
parseConfiguration(Text.get()->getBuffer(), &Style)) {
|
2014-06-12 10:50:04 +08:00
|
|
|
if (ec == ParseError::Unsuitable) {
|
2013-11-29 23:19:43 +08:00
|
|
|
if (!UnsuitableConfigFiles.empty())
|
|
|
|
UnsuitableConfigFiles.append(", ");
|
|
|
|
UnsuitableConfigFiles.append(ConfigFile);
|
2013-12-02 23:21:38 +08:00
|
|
|
continue;
|
2013-11-29 23:19:43 +08:00
|
|
|
}
|
2017-01-17 08:12:27 +08:00
|
|
|
return make_string_error("Error reading " + ConfigFile + ": " +
|
|
|
|
ec.message());
|
2013-09-30 21:31:48 +08:00
|
|
|
}
|
|
|
|
DEBUG(llvm::dbgs() << "Using configuration file " << ConfigFile << "\n");
|
|
|
|
return Style;
|
|
|
|
}
|
|
|
|
}
|
2017-01-17 08:12:27 +08:00
|
|
|
if (!UnsuitableConfigFiles.empty())
|
|
|
|
return make_string_error("Configuration file(s) do(es) not support " +
|
|
|
|
getLanguageName(Style.Language) + ": " +
|
|
|
|
UnsuitableConfigFiles);
|
2017-01-20 09:22:42 +08:00
|
|
|
return FallbackStyle;
|
2013-09-30 21:31:48 +08:00
|
|
|
}
|
|
|
|
|
2013-01-07 21:26:07 +08:00
|
|
|
} // namespace format
|
|
|
|
} // namespace clang
|