Bug 1960024: Remove checks for JS_HAS_INTL_API and MOZ_ICU4X. r=platform-i18n-reviewers,nordzilla

`JS_HAS_INTL_API` and `MOZ_ICU4X` are always set unless building js-standalone packages. And because "intl/lwbrk" isn't used for js-standalone packages, both options (`JS_HAS_INTL_API` and `MOZ_ICU4X`) are guaranteed to be defined. Differential Revision: https://phabricator.services.mozilla.com/D245272
2025-04-14 07:28:46 +00:00
parent 403888012a
commit f717d8d9cc
5 changed files with 37 additions and 101 deletions
--- a/intl/lwbrk/LineBreaker.cpp
+++ b/intl/lwbrk/LineBreaker.cpp
@@ -5,28 +5,25 @@

 #include "mozilla/intl/LineBreaker.h"

+#include "ICU4XDataProvider.h"
+#include "ICU4XLineBreakIteratorLatin1.hpp"
+#include "ICU4XLineBreakIteratorUtf16.hpp"
+#include "ICU4XLineSegmenter.h"
 #include "jisx4051class.h"
 #include "LineBreakCache.h"
 #include "nsComplexBreaker.h"
 #include "nsTArray.h"
 #include "nsUnicodeProperties.h"
+#include "nsThreadUtils.h"
 #include "mozilla/ArrayUtils.h"
-#include "mozilla/intl/Segmenter.h"
-#include "mozilla/intl/UnicodeProperties.h"
-
-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
-#  include "ICU4XDataProvider.h"
-#  include "ICU4XLineBreakIteratorLatin1.hpp"
-#  include "ICU4XLineBreakIteratorUtf16.hpp"
-#  include "ICU4XLineSegmenter.h"
 #include "mozilla/CheckedInt.h"
 #include "mozilla/ClearOnShutdown.h"
 #include "mozilla/intl/ICU4XGeckoDataProvider.h"
+#include "mozilla/intl/Segmenter.h"
+#include "mozilla/intl/UnicodeProperties.h"
 #include "mozilla/StaticPrefs_intl.h"
-#  include "nsThreadUtils.h"

 #include <mutex>
-#endif

 using namespace mozilla;
 using namespace mozilla::intl;
@@ -1000,7 +997,6 @@ static bool SuppressBreakForKeepAll(uint32_t aPrev, uint32_t aCh) {
         affectedByKeepAll(GetLineBreakClass(aCh));
 }

-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
 static capi::ICU4XLineBreakStrictness ConvertLineBreakRuleToICU4X(
    LineBreakRule aLevel) {
  switch (aLevel) {
@@ -1094,12 +1090,10 @@ static capi::ICU4XLineSegmenter* GetLineSegmenter(bool aUseDefault,
  MOZ_ASSERT(result.is_ok);
  return result.ok;
 }
-#endif

 void LineBreaker::ComputeBreakPositions(
    const char16_t* aChars, uint32_t aLength, WordBreakRule aWordBreak,
    LineBreakRule aLevel, bool aIsChineseOrJapanese, uint8_t* aBreakBefore) {
-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
  if (StaticPrefs::intl_icu4x_segmenter_enabled()) {
    if (aLength == 1) {
      // Although UAX#14 LB2 rule requires never breaking at the start of text
@@ -1178,7 +1172,6 @@ void LineBreaker::ComputeBreakPositions(

    return;
  }
-#endif

  uint32_t cur;
  int8_t lastClass = CLASS_NONE;
@@ -1309,7 +1302,6 @@ void LineBreaker::ComputeBreakPositions(const uint8_t* aChars, uint32_t aLength,
                                        LineBreakRule aLevel,
                                        bool aIsChineseOrJapanese,
                                        uint8_t* aBreakBefore) {
-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
  if (StaticPrefs::intl_icu4x_segmenter_enabled()) {
    if (aLength == 1) {
      // Although UAX#14 LB2 rule requires never breaking at the start of text
@@ -1348,7 +1340,6 @@ void LineBreaker::ComputeBreakPositions(const uint8_t* aChars, uint32_t aLength,
    }
    return;
  }
-#endif

  uint32_t cur;
  int8_t lastClass = CLASS_NONE;
--- a/intl/lwbrk/Segmenter.cpp
+++ b/intl/lwbrk/Segmenter.cpp
@@ -8,14 +8,6 @@

 #include "mozilla/intl/Segmenter.h"

-#include "mozilla/intl/LineBreaker.h"
-#include "mozilla/intl/WordBreaker.h"
-#include "mozilla/intl/UnicodeProperties.h"
-#include "mozilla/StaticPrefs_intl.h"
-#include "nsUnicodeProperties.h"
-#include "nsCharTraits.h"
-
-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
 #include "ICU4XDataProvider.h"
 #include "ICU4XGraphemeClusterSegmenter.h"
 #include "ICU4XLineSegmenter.h"
@@ -23,10 +15,15 @@
 #include "ICU4XWordSegmenter.h"
 #include "mozilla/ClearOnShutdown.h"
 #include "mozilla/intl/ICU4XGeckoDataProvider.h"
+#include "mozilla/intl/LineBreaker.h"
+#include "mozilla/intl/WordBreaker.h"
+#include "mozilla/intl/UnicodeProperties.h"
+#include "mozilla/StaticPrefs_intl.h"
+#include "nsUnicodeProperties.h"
+#include "nsCharTraits.h"
 #include "nsThreadUtils.h"

 #include <mutex>
-#endif

 using namespace mozilla::unicode;

@@ -45,7 +42,6 @@ Maybe<uint32_t> SegmentIteratorUtf16::Seek(uint32_t aPos) {
 LineBreakIteratorUtf16::LineBreakIteratorUtf16(Span<const char16_t> aText,
                                               const LineBreakOptions& aOptions)
    : SegmentIteratorUtf16(aText), mOptions(aOptions) {
-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
  if (!StaticPrefs::intl_icu4x_segmenter_enabled()) {
    return;
  }
@@ -55,22 +51,18 @@ LineBreakIteratorUtf16::LineBreakIteratorUtf16(Span<const char16_t> aText,
  mSegmenter = result.ok;
  mIterator = capi::ICU4XLineSegmenter_segment_utf16(
      mSegmenter, mText.Elements(), mText.Length());
-#endif
 }

 LineBreakIteratorUtf16::~LineBreakIteratorUtf16() {
-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
  if (mIterator) {
    capi::ICU4XLineBreakIteratorUtf16_destroy(mIterator);
  }
  if (mSegmenter) {
    capi::ICU4XLineSegmenter_destroy(mSegmenter);
  }
-#endif
 }

 Maybe<uint32_t> LineBreakIteratorUtf16::Next() {
-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
  if (mIterator) {
    const int32_t nextPos = capi::ICU4XLineBreakIteratorUtf16_next(mIterator);
    if (nextPos < 0) {
@@ -82,7 +74,6 @@ Maybe<uint32_t> LineBreakIteratorUtf16::Next() {
    mPos = nextPos;
    return Some(mPos);
  }
-#endif
  const int32_t nextPos =
      LineBreaker::Next(mText.Elements(), mText.Length(), mPos);
  if (nextPos == NS_LINEBREAKER_NEED_MORE_TEXT) {
@@ -93,7 +84,6 @@ Maybe<uint32_t> LineBreakIteratorUtf16::Next() {
 }

 Maybe<uint32_t> LineBreakIteratorUtf16::Seek(uint32_t aPos) {
-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
  if (mIterator) {
    if (mPos >= aPos) {
      return Next();
@@ -113,13 +103,11 @@ Maybe<uint32_t> LineBreakIteratorUtf16::Seek(uint32_t aPos) {

    return Next();
  }
-#endif
  return SegmentIteratorUtf16::Seek(aPos);
 }

 WordBreakIteratorUtf16::WordBreakIteratorUtf16(Span<const char16_t> aText)
    : SegmentIteratorUtf16(aText) {
-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
  if (!StaticPrefs::intl_icu4x_segmenter_enabled()) {
    return;
  }
@@ -129,24 +117,20 @@ WordBreakIteratorUtf16::WordBreakIteratorUtf16(Span<const char16_t> aText)
  mSegmenter = result.ok;
  mIterator = capi::ICU4XWordSegmenter_segment_utf16(
      mSegmenter, mText.Elements(), mText.Length());
-#endif
 }

 WordBreakIteratorUtf16::~WordBreakIteratorUtf16() {
-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
  if (mIterator) {
    capi::ICU4XWordBreakIteratorUtf16_destroy(mIterator);
  }
  if (mSegmenter) {
    capi::ICU4XWordSegmenter_destroy(mSegmenter);
  }
-#endif
 }

 void WordBreakIteratorUtf16::Reset(Span<const char16_t> aText) {
  mPos = 0;
  mText = aText;
-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
  if (mIterator) {
    capi::ICU4XWordBreakIteratorUtf16_destroy(mIterator);
    mIterator = nullptr;
@@ -156,11 +140,9 @@ void WordBreakIteratorUtf16::Reset(Span<const char16_t> aText) {
  }
  mIterator = capi::ICU4XWordSegmenter_segment_utf16(
      mSegmenter, mText.Elements(), mText.Length());
-#endif
 }

 Maybe<uint32_t> WordBreakIteratorUtf16::Next() {
-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
  if (mIterator) {
    const int32_t nextPos = capi::ICU4XWordBreakIteratorUtf16_next(mIterator);
    if (nextPos < 0) {
@@ -172,7 +154,6 @@ Maybe<uint32_t> WordBreakIteratorUtf16::Next() {
    mPos = nextPos;
    return Some(mPos);
  }
-#endif
  const int32_t nextPos =
      WordBreaker::Next(mText.Elements(), mText.Length(), mPos);
  if (nextPos == NS_WORDBREAKER_NEED_MORE_TEXT) {
@@ -183,7 +164,6 @@ Maybe<uint32_t> WordBreakIteratorUtf16::Next() {
 }

 Maybe<uint32_t> WordBreakIteratorUtf16::Seek(uint32_t aPos) {
-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
  if (mIterator) {
    if (mPos >= aPos) {
      return Next();
@@ -203,19 +183,15 @@ Maybe<uint32_t> WordBreakIteratorUtf16::Seek(uint32_t aPos) {

    return Next();
  }
-#endif
  return SegmentIteratorUtf16::Seek(aPos);
 }

-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
 capi::ICU4XGraphemeClusterSegmenter*
    GraphemeClusterBreakIteratorUtf16::sSegmenter = nullptr;
-#endif

 GraphemeClusterBreakIteratorUtf16::GraphemeClusterBreakIteratorUtf16(
    Span<const char16_t> aText)
    : SegmentIteratorUtf16(aText) {
-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
  if (!StaticPrefs::intl_icu4x_segmenter_enabled()) {
    return;
  }
@@ -239,15 +215,12 @@ GraphemeClusterBreakIteratorUtf16::GraphemeClusterBreakIteratorUtf16(
  MOZ_RELEASE_ASSERT(sSegmenter);
  mIterator = capi::ICU4XGraphemeClusterSegmenter_segment_utf16(
      sSegmenter, mText.Elements(), mText.Length());
-#endif
 }

 GraphemeClusterBreakIteratorUtf16::~GraphemeClusterBreakIteratorUtf16() {
-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
  if (mIterator) {
    capi::ICU4XGraphemeClusterBreakIteratorUtf16_destroy(mIterator);
  }
-#endif
 }

 enum HSType {
@@ -266,7 +239,6 @@ static HSType GetHangulSyllableType(uint32_t aCh) {

 Maybe<uint32_t> GraphemeClusterBreakIteratorUtf16::Next() {
  const auto len = mText.Length();
-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
  if (mIterator) {
    const int32_t nextPos =
        capi::ICU4XGraphemeClusterBreakIteratorUtf16_next(mIterator);
@@ -279,7 +251,6 @@ Maybe<uint32_t> GraphemeClusterBreakIteratorUtf16::Next() {
    mPos = nextPos;
    return Some(mPos);
  }
-#endif
  if (mPos >= len) {
    // The iterator has already reached the end.
    return Nothing();
@@ -401,7 +372,6 @@ Maybe<uint32_t> GraphemeClusterBreakIteratorUtf16::Next() {
 }

 Maybe<uint32_t> GraphemeClusterBreakIteratorUtf16::Seek(uint32_t aPos) {
-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
  if (mIterator) {
    if (mPos >= aPos) {
      return Next();
@@ -422,7 +392,6 @@ Maybe<uint32_t> GraphemeClusterBreakIteratorUtf16::Seek(uint32_t aPos) {

    return Next();
  }
-#endif
  return SegmentIteratorUtf16::Seek(aPos);
 }

@@ -462,7 +431,6 @@ Maybe<uint32_t> GraphemeClusterBreakReverseIteratorUtf16::Seek(uint32_t aPos) {
  return Next();
 }

-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
 SentenceBreakIteratorUtf16::SentenceBreakIteratorUtf16(
    Span<const char16_t> aText)
    : SegmentIteratorUtf16(aText) {
@@ -523,16 +491,9 @@ Maybe<uint32_t> SentenceBreakIteratorUtf16::Next() {
  mPos = nextPos;
  return Some(mPos);
 }
-#endif

 Result<UniquePtr<Segmenter>, ICUError> Segmenter::TryCreate(
    Span<const char> aLocale, const SegmenterOptions& aOptions) {
-#if !defined(MOZ_ICU4X) || !defined(JS_HAS_INTL_API)
-  if (aOptions.mGranularity == SegmenterGranularity::Sentence) {
-    // Grapheme and Sentence iterator are not yet implemented.
-    return Err(ICUError::InternalError);
-  }
-#endif
  return MakeUnique<Segmenter>(aLocale, aOptions);
 }

@@ -542,11 +503,9 @@ UniquePtr<SegmentIteratorUtf16> Segmenter::Segment(
    case SegmenterGranularity::Grapheme:
      return MakeUnique<GraphemeClusterBreakIteratorUtf16>(aText);
    case SegmenterGranularity::Sentence:
-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
      if (StaticPrefs::intl_icu4x_segmenter_enabled()) {
        return MakeUnique<SentenceBreakIteratorUtf16>(aText);
      }
-#endif
      MOZ_ASSERT_UNREACHABLE("Unimplemented yet!");
      return nullptr;
    case SegmenterGranularity::Word:
--- a/intl/lwbrk/Segmenter.h
+++ b/intl/lwbrk/Segmenter.h
@@ -15,7 +15,6 @@
 #include "mozilla/Span.h"
 #include "mozilla/UniquePtr.h"

-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
 namespace capi {
 struct ICU4XLineSegmenter;
 struct ICU4XLineBreakIteratorUtf16;
@@ -26,7 +25,6 @@ struct ICU4XGraphemeClusterBreakIteratorUtf16;
 struct ICU4XSentenceSegmenter;
 struct ICU4XSentenceBreakIteratorUtf16;
 }  // namespace capi
-#endif

 namespace mozilla::intl {

@@ -125,10 +123,8 @@ class LineBreakIteratorUtf16 final : public SegmentIteratorUtf16 {
 private:
  LineBreakOptions mOptions;

-#ifdef MOZ_ICU4X
  capi::ICU4XLineSegmenter* mSegmenter = nullptr;
  capi::ICU4XLineBreakIteratorUtf16* mIterator = nullptr;
-#endif
 };

 /**
@@ -143,11 +139,9 @@ class WordBreakIteratorUtf16 final : public SegmentIteratorUtf16 {
  Maybe<uint32_t> Next() override;
  Maybe<uint32_t> Seek(uint32_t aPos) override;

-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
 private:
  capi::ICU4XWordSegmenter* mSegmenter = nullptr;
  capi::ICU4XWordBreakIteratorUtf16* mIterator = nullptr;
-#endif
 };

 /**
@@ -161,11 +155,9 @@ class GraphemeClusterBreakIteratorUtf16 final : public SegmentIteratorUtf16 {
  Maybe<uint32_t> Next() override;
  Maybe<uint32_t> Seek(uint32_t aPos) override;

-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
 private:
  static capi::ICU4XGraphemeClusterSegmenter* sSegmenter;
  capi::ICU4XGraphemeClusterBreakIteratorUtf16* mIterator = nullptr;
-#endif
 };

 /**
@@ -183,7 +175,6 @@ class GraphemeClusterBreakReverseIteratorUtf16 final
  Maybe<uint32_t> Seek(uint32_t aPos) override;
 };

-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
 /**
 * Sentence break iterator for UTF-16 text.
 */
@@ -199,7 +190,6 @@ class SentenceBreakIteratorUtf16 final : public SegmentIteratorUtf16 {
  capi::ICU4XSentenceSegmenter* mSegmenter = nullptr;
  capi::ICU4XSentenceBreakIteratorUtf16* mIterator = nullptr;
 };
-#endif

 /**
 * This component is a Mozilla-focused API for working with segmenters in
--- a/intl/lwbrk/WordBreaker.cpp
+++ b/intl/lwbrk/WordBreaker.cpp
@@ -3,22 +3,20 @@
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

-#include "mozilla/CheckedInt.h"
-#include "mozilla/intl/UnicodeProperties.h"
 #include "mozilla/intl/WordBreaker.h"
-#include "mozilla/StaticPrefs_layout.h"
-#include "nsComplexBreaker.h"
-#include "nsTArray.h"
-#include "nsUnicodeProperties.h"

-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
 #include "ICU4XDataProvider.h"
 #include "ICU4XWordBreakIteratorUtf16.hpp"
 #include "ICU4XWordSegmenter.hpp"
+#include "mozilla/CheckedInt.h"
 #include "mozilla/intl/ICU4XGeckoDataProvider.h"
+#include "mozilla/intl/UnicodeProperties.h"
 #include "mozilla/StaticPrefs_intl.h"
+#include "mozilla/StaticPrefs_layout.h"
+#include "nsComplexBreaker.h"
+#include "nsTArray.h"
 #include "nsUnicharUtils.h"
-#endif
+#include "nsUnicodeProperties.h"

 using mozilla::intl::Script;
 using mozilla::intl::UnicodeProperties;
@@ -99,7 +97,6 @@ WordRange WordBreaker::FindWord(const nsAString& aText, uint32_t aPos,

  WordRange range{0, len.value()};

-#if defined(MOZ_ICU4X) && defined(JS_HAS_INTL_API)
  if (StaticPrefs::intl_icu4x_segmenter_enabled()) {
    auto result =
        capi::ICU4XWordSegmenter_create_auto(mozilla::intl::GetDataProvider());
@@ -148,7 +145,6 @@ WordRange WordBreaker::FindWord(const nsAString& aText, uint32_t aPos,

    return range;
  }
-#endif

  WordBreakClass c = GetClass(aText[aPos]);

--- a/intl/lwbrk/moz.build
+++ b/intl/lwbrk/moz.build
@@ -44,10 +44,10 @@ else:
        "rulebrk.c",
    ]

-if CONFIG["JS_HAS_INTL_API"] and CONFIG["MOZ_ICU4X"]:
 LOCAL_INCLUDES += [
    "/intl/icu_capi/bindings/cpp",
 ]
+
 # Disable warnings when including C++ headers of ICU4X.
 # - https://github.com/rust-diplomat/diplomat/issues/277
 CXXFLAGS += [