IntegerLiteralSeparatorFixer.cpp

Go to the documentation of this file.

//===--- IntegerLiteralSeparatorFixer.cpp -----------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
///
/// \file
/// This file implements IntegerLiteralSeparatorFixer that fixes C++ integer
/// literal separators.
///
//===----------------------------------------------------------------------===//
 
#include "IntegerLiteralSeparatorFixer.h"
 
namespace clang {
namespace format {
 
enum class Base { Binary, Decimal, Hex, Other };
 
static Base getBase(StringRef IntegerLiteral) {
  assert(IntegerLiteral.size() > 1);
 
  if (IntegerLiteral[0] > '0') {
    assert(IntegerLiteral[0] <= '9');
    return Base::Decimal;
  }
 
  assert(IntegerLiteral[0] == '0');
 
  switch (IntegerLiteral[1]) {
  case 'b':
  case 'B':
    return Base::Binary;
  case 'x':
  case 'X':
    return Base::Hex;
  default:
    return Base::Other;
  }
}
 
std::pair<tooling::Replacements, unsigned>
IntegerLiteralSeparatorFixer::process(const Environment &Env,
                                      const FormatStyle &Style) {
  const auto LangOpts = getFormattingLangOpts(Style);
 
  switch (Style.Language) {
  case FormatStyle::LK_CSharp:
  case FormatStyle::LK_Java:
  case FormatStyle::LK_JavaScript:
    Separator = '_';
    break;
  case FormatStyle::LK_C:
  case FormatStyle::LK_Cpp:
  case FormatStyle::LK_ObjC:
    if (!LangOpts.AllowLiteralDigitSeparator)
      return {};
    Separator = '\'';
    break;
  default:
    return {};
  }
 
  const auto &Option = Style.IntegerLiteralSeparator;
  const auto Binary = Option.Binary;
  const auto Decimal = Option.Decimal;
  const auto Hex = Option.Hex;
  const bool SkipBinary = Binary == 0;
  const bool SkipDecimal = Decimal == 0;
  const bool SkipHex = Hex == 0;
 
  if (SkipBinary && SkipDecimal && SkipHex)
    return {};
 
  auto CalcMinAndMax = [](int DigitsPerGroup, int MinDigitsInsert,
                          int MaxDigitsRemove) {
    MinDigitsInsert = std::max(MinDigitsInsert, DigitsPerGroup + 1);
    if (MinDigitsInsert < 1)
      MaxDigitsRemove = 0;
    else if (MaxDigitsRemove < 1 || MaxDigitsRemove >= MinDigitsInsert)
      MaxDigitsRemove = MinDigitsInsert - 1;
    return std::pair(MinDigitsInsert, MaxDigitsRemove);
  };
 
  const auto [BinaryMinDigitsInsert, BinaryMaxDigitsRemove] = CalcMinAndMax(
      Binary, Option.BinaryMinDigitsInsert, Option.BinaryMaxDigitsRemove);
  const auto [DecimalMinDigitsInsert, DecimalMaxDigitsRemove] = CalcMinAndMax(
      Decimal, Option.DecimalMinDigitsInsert, Option.DecimalMaxDigitsRemove);
  const auto [HexMinDigitsInsert, HexMaxDigitsRemove] =
      CalcMinAndMax(Hex, Option.HexMinDigitsInsert, Option.HexMaxDigitsRemove);
 
  const auto &SourceMgr = Env.getSourceManager();
  AffectedRangeManager AffectedRangeMgr(SourceMgr, Env.getCharRanges());
 
  const auto ID = Env.getFileID();
  Lexer Lex(ID, SourceMgr.getBufferOrFake(ID), SourceMgr, LangOpts);
  Lex.SetCommentRetentionState(true);
 
  Token Tok;
  tooling::Replacements Result;
 
  for (bool Skip = false; !Lex.LexFromRawLexer(Tok);) {
    auto Length = Tok.getLength();
    if (Length < 2)
      continue;
    auto Location = Tok.getLocation();
    auto Text = StringRef(SourceMgr.getCharacterData(Location), Length);
    if (Tok.is(tok::comment)) {
      if (isClangFormatOff(Text))
        Skip = true;
      else if (isClangFormatOn(Text))
        Skip = false;
      continue;
    }
    if (Skip || Tok.isNot(tok::numeric_constant) || Text[0] == '.' ||
        !AffectedRangeMgr.affectsCharSourceRange(
            CharSourceRange::getCharRange(Location, Tok.getEndLoc()))) {
      continue;
    }
    const auto B = getBase(Text);
    const bool IsBase2 = B == Base::Binary;
    const bool IsBase10 = B == Base::Decimal;
    const bool IsBase16 = B == Base::Hex;
    if ((IsBase2 && SkipBinary) || (IsBase10 && SkipDecimal) ||
        (IsBase16 && SkipHex) || B == Base::Other) {
      continue;
    }
    if (Style.isCpp()) {
      // Hex alpha digits a-f/A-F must be at the end of the string literal.
      static constexpr StringRef Suffixes("_himnsuyd");
      if (const auto Pos =
              Text.find_first_of(IsBase16 ? Suffixes.drop_back() : Suffixes);
          Pos != StringRef::npos) {
        Text = Text.substr(0, Pos);
        Length = Pos;
      }
    }
    if ((IsBase10 && Text.find_last_of(".eEfFdDmM") != StringRef::npos) ||
        (IsBase16 && Text.find_last_of(".pP") != StringRef::npos)) {
      continue;
    }
    const auto Start = Text[0] == '0' ? 2 : 0;
    auto End = Text.find_first_of("uUlLzZn", Start);
    if (End == StringRef::npos)
      End = Length;
    if (Start > 0 || End < Length) {
      Length = End - Start;
      Text = Text.substr(Start, Length);
    }
    auto DigitsPerGroup = Decimal;
    auto MinDigitsInsert = DecimalMinDigitsInsert;
    auto MaxDigitsRemove = DecimalMaxDigitsRemove;
    if (IsBase2) {
      DigitsPerGroup = Binary;
      MinDigitsInsert = BinaryMinDigitsInsert;
      MaxDigitsRemove = BinaryMaxDigitsRemove;
    } else if (IsBase16) {
      DigitsPerGroup = Hex;
      MinDigitsInsert = HexMinDigitsInsert;
      MaxDigitsRemove = HexMaxDigitsRemove;
    }
    const auto SeparatorCount = Text.count(Separator);
    const int DigitCount = Length - SeparatorCount;
    if (DigitCount > MaxDigitsRemove && DigitCount < MinDigitsInsert)
      continue;
    const bool RemoveSeparator =
        DigitsPerGroup < 0 || DigitCount <= MaxDigitsRemove;
    if (RemoveSeparator && SeparatorCount == 0)
      continue;
    if (!RemoveSeparator && SeparatorCount > 0 &&
        checkSeparator(Text, DigitsPerGroup)) {
      continue;
    }
    const auto &Formatted =
        format(Text, DigitsPerGroup, DigitCount, RemoveSeparator);
    assert(Formatted != Text);
    if (Start > 0)
      Location = Location.getLocWithOffset(Start);
    cantFail(Result.add(
        tooling::Replacement(SourceMgr, Location, Length, Formatted)));
  }
 
  return {Result, 0};
}
 
bool IntegerLiteralSeparatorFixer::checkSeparator(StringRef IntegerLiteral,
                                                  int DigitsPerGroup) const {
  assert(DigitsPerGroup > 0);
 
  int I = 0;
  for (auto C : llvm::reverse(IntegerLiteral)) {
    if (C == Separator) {
      if (I < DigitsPerGroup)
        return false;
      I = 0;
    } else {
      if (I == DigitsPerGroup)
        return false;
      ++I;
    }
  }
 
  return true;
}
 
std::string IntegerLiteralSeparatorFixer::format(StringRef IntegerLiteral,
                                                 int DigitsPerGroup,
                                                 int DigitCount,
                                                 bool RemoveSeparator) const {
  assert(DigitsPerGroup != 0);
 
  std::string Formatted;
 
  if (RemoveSeparator) {
    for (auto C : IntegerLiteral)
      if (C != Separator)
        Formatted.push_back(C);
    return Formatted;
  }
 
  int Remainder = DigitCount % DigitsPerGroup;
 
  int I = 0;
  for (auto C : IntegerLiteral) {
    if (C == Separator)
      continue;
    if (I == (Remainder > 0 ? Remainder : DigitsPerGroup)) {
      Formatted.push_back(Separator);
      I = 0;
      Remainder = 0;
    }
    Formatted.push_back(C);
    ++I;
  }
 
  return Formatted;
}
 
} // namespace format
} // namespace clang