address comments, rename CharSet to EncodingConverter

Author: abhina-sree

llvm/include/llvm/Support/CharSet.h renamed to llvm/include/llvm/Support/EncodingConverter.h

@@ -1,4 +1,4 @@
-//===-- CharSet.h - Characters set conversion class ---------------*- C++ -*-=//
+//===-- EncodingConverter.h - Encoding conversion class -----------*- C++ -*-=//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -12,8 +12,8 @@
 ///
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_SUPPORT_CHARSET_H
-#define LLVM_SUPPORT_CHARSET_H
+#ifndef LLVM_SUPPORT_ENCODING_CONVERTER_H
+#define LLVM_SUPPORT_ENCODING_CONVERTER_H
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
@@ -44,8 +44,8 @@ class EncodingConverterImplBase {
   ///   - std::errc::invalid_argument: The input contains an incomplete
   ///     multibyte sequence.
   ///
-  /// If the destination charset is a stateful character set, the shift state
-  /// will be set to the initial state.
+  /// If the destination encoding is stateful, the shift state will be set
+  /// to the initial state.
   ///
   /// In case of an error, the result string contains the successfully converted
   /// part of the input string.
@@ -77,7 +77,7 @@ enum class TextEncoding {
   IBM1047
 };
 
-/// Utility class to convert between different character set encodings.
+/// Utility class to convert between different character encodings.
 class EncodingConverter {
   std::unique_ptr<details::EncodingConverterImplBase> Converter;
 
@@ -89,19 +89,18 @@ class EncodingConverter {
   /// Creates a EncodingConverter instance.
   /// Returns std::errc::invalid_argument in case the requested conversion is
   /// not supported.
-  /// \param[in] CSFrom the source character encoding
-  /// \param[in] CSTo the target character encoding
+  /// \param[in] From the source character encoding
+  /// \param[in] To the target character encoding
   /// \return a EncodingConverter instance or an error code
-  static ErrorOr<EncodingConverter> create(TextEncoding CSFrom,
-                                           TextEncoding CSTo);
+  static ErrorOr<EncodingConverter> create(TextEncoding From, TextEncoding To);
 
   /// Creates a EncodingConverter instance.
   /// Returns std::errc::invalid_argument in case the requested conversion is
   /// not supported.
-  /// \param[in] CPFrom name of the source character encoding
-  /// \param[in] CPTo name of the target character encoding
+  /// \param[in] From name of the source character encoding
+  /// \param[in] To name of the target character encoding
   /// \return a EncodingConverter instance or an error code
-  static ErrorOr<EncodingConverter> create(StringRef CPFrom, StringRef CPTo);
+  static ErrorOr<EncodingConverter> create(StringRef From, StringRef To);
 
   EncodingConverter(const EncodingConverter &) = delete;
   EncodingConverter &operator=(const EncodingConverter &) = delete;

llvm/lib/Support/CMakeLists.txt

@@ -162,7 +162,6 @@ add_llvm_component_library(LLVMSupport
   CachePruning.cpp
   Caching.cpp
   circular_raw_ostream.cpp
-  CharSet.cpp
   Chrono.cpp
   COM.cpp
   CodeGenCoverage.cpp
@@ -187,6 +186,7 @@ add_llvm_component_library(LLVMSupport
   ELFAttributes.cpp
   ELFAttrParserCompact.cpp
   ELFAttrParserExtended.cpp
+  EncodingConverter.cpp
   Error.cpp
   ErrorHandling.cpp
   ExponentialBackoff.cpp

llvm/lib/Support/CharSet.cpp renamed to llvm/lib/Support/EncodingConverter.cpp

@@ -1,4 +1,4 @@
-//===-- CharSet.cpp - Characters sets conversion class ------------*- C++ -*-=//
+//===-- EncodingConverter.cpp - Encoding conversion class ---------*- C++ -*-=//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -8,11 +8,11 @@
 ///
 /// \file
 /// This file provides utility classes to convert between different character
-/// set encodings.
+/// encodings.
 ///
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Support/CharSet.h"
+#include "llvm/Support/EncodingConverter.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
@@ -46,10 +46,10 @@ static void normalizeCharSetName(StringRef CSName,
   }
 }
 
-// Maps the charset name to enum constant if possible.
-static std::optional<TextEncoding> getKnownEncoding(StringRef CSName) {
+// Maps the encoding name to enum constant if possible.
+static std::optional<TextEncoding> getKnownEncoding(StringRef Name) {
   SmallString<16> Normalized;
-  normalizeCharSetName(CSName, Normalized);
+  normalizeCharSetName(Name, Normalized);
   if (Normalized.equals("utf8"))
     return TextEncoding::UTF8;
   if (Normalized.equals("ibm1047"))
@@ -63,9 +63,8 @@ HandleOverflow(size_t &Capacity, char *&Output, size_t &OutputLength,
   // No space left in output buffer. Double the size of the underlying
   // memory in the SmallVectorImpl, adjust pointer and length and continue
   // the conversion.
-  Capacity = (Capacity < std::numeric_limits<size_t>::max() / 2)
-                 ? 2 * Capacity
-                 : std::numeric_limits<size_t>::max();
+  Capacity =
+      (Capacity < Result.max_size() / 2) ? 2 * Capacity : Result.max_size();
   Result.resize(0);
   Result.resize_for_overwrite(Capacity);
   Output = static_cast<char *>(Result.data());
@@ -80,9 +79,9 @@ enum ConversionType {
 
 // Support conversion between EBCDIC 1047 and UTF-8. This class uses
 // built-in translation tables that allow for translation between the
-// aforementioned character sets. The use of tables for conversion is only
+// aforementioned encodings. The use of tables for conversion is only
 // possible because EBCDIC 1047 is a single-byte, stateless encoding; other
-// character sets are not supported.
+// encodings are not supported.
 class EncodingConverterTable : public details::EncodingConverterImplBase {
   const ConversionType ConvType;
 
@@ -169,8 +168,7 @@ EncodingConverterICU::convertString(StringRef Source,
                    /*pivotLimit=*/NULL, /*reset=*/true,
                    /*flush=*/true, &EC);
     if (U_FAILURE(EC)) {
-      if (EC == U_BUFFER_OVERFLOW_ERROR &&
-          Capacity < std::numeric_limits<size_t>::max()) {
+      if (EC == U_BUFFER_OVERFLOW_ERROR && Capacity < Result.max_size()) {
         HandleOverflow(Capacity, Output, OutputLength, Result);
         continue;
       }
@@ -246,7 +244,7 @@ EncodingConverterIconv::convertString(StringRef Source,
                       this](size_t Ret) {
     if (Ret == static_cast<size_t>(-1)) {
       // An error occured. Check if we can gracefully handle it.
-      if (errno == E2BIG && Capacity < std::numeric_limits<size_t>::max()) {
+      if (errno == E2BIG && Capacity < Result.max_size()) {
         HandleOverflow(Capacity, Output, OutputLength, Result);
         // Reset converter
         iconv(ConvDesc, nullptr, nullptr, nullptr, nullptr);
@@ -301,7 +299,7 @@ void EncodingConverterIconv::reset() {
 ErrorOr<EncodingConverter> EncodingConverter::create(TextEncoding CPFrom,
                                                      TextEncoding CPTo) {
 
-  // text encodings should be distinct
+  // Text encodings should be distinct.
   if (CPFrom == CPTo)
     return std::make_error_code(std::errc::invalid_argument);
 
@@ -317,22 +315,22 @@ ErrorOr<EncodingConverter> EncodingConverter::create(TextEncoding CPFrom,
       std::make_unique<EncodingConverterTable>(Conversion));
 }
 
-ErrorOr<EncodingConverter> EncodingConverter::create(StringRef CSFrom,
-                                                     StringRef CSTo) {
-  std::optional<TextEncoding> From = getKnownEncoding(CSFrom);
-  std::optional<TextEncoding> To = getKnownEncoding(CSTo);
-  if (From && To) {
-    ErrorOr<EncodingConverter> Converter = create(*From, *To);
+ErrorOr<EncodingConverter> EncodingConverter::create(StringRef From,
+                                                     StringRef To) {
+  std::optional<TextEncoding> FromEncoding = getKnownEncoding(From);
+  std::optional<TextEncoding> ToEncoding = getKnownEncoding(To);
+  if (FromEncoding && ToEncoding) {
+    ErrorOr<EncodingConverter> Converter = create(*FromEncoding, *ToEncoding);
     if (Converter)
       return Converter;
   }
 #if HAVE_ICU
   UErrorCode EC = U_ZERO_ERROR;
-  UConverterUniquePtr FromConvDesc(ucnv_open(CSFrom.str().c_str(), &EC));
+  UConverterUniquePtr FromConvDesc(ucnv_open(From.str().c_str(), &EC));
   if (U_FAILURE(EC)) {
     return std::error_code(errno, std::generic_category());
   }
-  UConverterUniquePtr ToConvDesc(ucnv_open(CSTo.str().c_str(), &EC));
+  UConverterUniquePtr ToConvDesc(ucnv_open(To.str().c_str(), &EC));
   if (U_FAILURE(EC)) {
     return std::error_code(errno, std::generic_category());
   }
@@ -341,7 +339,7 @@ ErrorOr<EncodingConverter> EncodingConverter::create(StringRef CSFrom,
                                              std::move(ToConvDesc));
   return EncodingConverter(std::move(Converter));
 #elif HAVE_ICONV
-  iconv_t ConvDesc = iconv_open(CSTo.str().c_str(), CSFrom.str().c_str());
+  iconv_t ConvDesc = iconv_open(To.str().c_str(), From.str().c_str());
   if (ConvDesc == (iconv_t)-1)
     return std::error_code(errno, std::generic_category());
   return EncodingConverter(std::make_unique<EncodingConverterIconv>(ConvDesc));

llvm/unittests/Support/CMakeLists.txt

@@ -20,7 +20,6 @@ add_llvm_unittest(SupportTests
   CrashRecoveryTest.cpp
   Caching.cpp
   Casting.cpp
-  CharSetTest.cpp
   CheckedArithmeticTest.cpp
   Chrono.cpp
   CommandLineTest.cpp
@@ -40,6 +39,7 @@ add_llvm_unittest(SupportTests
   ErrnoTest.cpp
   ErrorOrTest.cpp
   ErrorTest.cpp
+  EncodingConverterTest.cpp
   ExponentialBackoffTest.cpp
   ExtensibleRTTITest.cpp
   FileCollectorTest.cpp

llvm/unittests/Support/CharSetTest.cpp renamed to llvm/unittests/Support/EncodingConverterTest.cpp

@@ -1,12 +1,12 @@
-//===- unittests/Support/CharSetTest.cpp - Charset conversion tests -------===//
+//===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Support/CharSet.h"
+#include "llvm/Support/EncodingConverter.h"
 #include "llvm/ADT/SmallString.h"
 #include "gtest/gtest.h"
 using namespace llvm;
@@ -53,7 +53,7 @@ static const char EarthIBM939[] =
 static const char EarthUTFExtraPartial[] =
     "\x45\x61\x72\x74\x68\xe5\x9c\xb0\xe7\x90\x83\xe5";
 
-TEST(CharSet, FromUTF8) {
+TEST(Encoding, FromUTF8) {
   // Hello string.
   StringRef Src(HelloA);
   SmallString<64> Dst;
@@ -93,7 +93,7 @@ TEST(CharSet, FromUTF8) {
   EXPECT_EQ(EC, std::errc::illegal_byte_sequence);
 }
 
-TEST(CharSet, ToUTF8) {
+TEST(Encoding, ToUTF8) {
   // Hello string.
   StringRef Src(HelloE);
   SmallString<64> Dst;
@@ -128,7 +128,7 @@ TEST(CharSet, ToUTF8) {
   EXPECT_STREQ(AccentUTF, static_cast<std::string>(Dst).c_str());
 }
 
-TEST(CharSet, RoundTrip) {
+TEST(Encoding, RoundTrip) {
   ErrorOr<EncodingConverter> ConvToUTF16 =
       EncodingConverter::create("IBM-1047", "UTF-16");
   // Stop test if conversion is not supported (no underlying iconv support).
@@ -170,7 +170,7 @@ TEST(CharSet, RoundTrip) {
   EXPECT_STREQ(SrcStr, static_cast<std::string>(Dst3Str).c_str());
 }
 
-TEST(CharSet, ShiftState2022) {
+TEST(Encoding, ShiftState2022) {
   // Earth string.
   StringRef Src(EarthUTF);
   SmallString<8> Dst;
@@ -190,7 +190,7 @@ TEST(CharSet, ShiftState2022) {
   EXPECT_STREQ(EarthISO2022, static_cast<std::string>(Dst).c_str());
 }
 
-TEST(CharSet, ShiftState2022Partial) {
+TEST(Encoding, InvalidInput) {
   // Earth string.
   StringRef Src(EarthUTFExtraPartial);
   SmallString<8> Dst;
@@ -204,12 +204,12 @@ TEST(CharSet, ShiftState2022Partial) {
     return;
   }
 
-  // Check that the string is properly converted.
+  // Check that the string failed to convert.
   std::error_code EC = ConvTo2022->convert(Src, Dst);
   EXPECT_TRUE(EC);
 }
 
-TEST(CharSet, ShiftStateIBM939) {
+TEST(Encoding, ShiftStateIBM939) {
   // Earth string.
   StringRef Src(EarthUTF);
   SmallString<64> Dst;