temp

Author: catamorphism

icu4c/source/i18n/messageformat2.cpp

@@ -342,6 +342,11 @@ FunctionContext MessageFormatter::makeFunctionContext(const FunctionOptions& opt
         context.getErrors().setFormattingError(functionName, status);
         return env.createFallback(fallbackStr, status);
     }
+    if (status == U_MF_BAD_OPTION) {
+        status = U_ZERO_ERROR;
+        context.getErrors().setBadOption(functionName, status);
+        return env.createFallback(fallbackStr, status);
+    }
     if (U_FAILURE(status)) {
         return env.bogus();
     }
@@ -440,7 +445,16 @@ void MessageFormatter::formatPattern(MessageContext& context,
                   const FunctionValue* val = partVal.getValue(status);
                   // Shouldn't be null or a fallback
                   U_ASSERT(U_SUCCESS(status));
+
+                  // See comment in matchSelectorKeys()
+                  bool badSelectOption = !checkSelectOption(*val);
                   result += val->formatToString(status);
+
+                  if (badSelectOption) {
+                      context.getErrors().setRecoverableBadOption(val->getFunctionName(), status);
+                      CHECK_ERROR(status);
+                  }
+
                   // Handle formatting errors. `formatToString()` can't take a context and thus can't
                   // register an error directly
                   if (status == U_MF_FORMATTING_ERROR) {
@@ -490,6 +504,30 @@ void MessageFormatter::resolveSelectors(MessageContext& context, Environment& en
     }
 }
 
+bool MessageFormatter::checkSelectOption(const FunctionValue& val) const {
+    const UnicodeString& name = val.getFunctionName();
+
+    if (name != UnicodeString("number") && name != UnicodeString("integer")) {
+        return true;
+    }
+
+    // Per the spec, if the "select" option is present, it must have been
+    // set from a literal
+
+    // Returns false if the `select` option is present and it was not set from a literal
+
+    const FunctionOptions& opts = val.getResolvedOptions();
+
+    // OK if the option wasn't present
+    UErrorCode localErrorCode = U_ZERO_ERROR;
+    opts.getFunctionOption(options::SELECT, localErrorCode);
+    if (U_FAILURE(localErrorCode)) {
+        return true;
+    }
+    // Otherwise, return true if the option was set from a literal
+    return opts.wasSetFromLiteral(options::SELECT);
+}
+
 // See https://github.com/unicode-org/message-format-wg/blob/main/spec/formatting.md#resolve-preferences
 // `keys` and `matches` are vectors of strings
 void MessageFormatter::matchSelectorKeys(const UVector& keys,
@@ -531,10 +569,27 @@ void MessageFormatter::matchSelectorKeys(const UVector& keys,
     // Call the selector
     // Caller checked for fallback, so it's safe to call getValue()
     const FunctionValue* rvVal = rv.getValue(status);
+
+    // This condition can't be checked in the selector.
+    // Effectively, there are two different kinds of "bad option" errors:
+    // one that can be recovered from (used for select=$var) and one that
+    // can't (used for bad digit size options and other cases).
+    // The checking of the recoverable error has to be done here; otherwise,
+    // the "bad option" signaled by the selector implementation would cause
+    // fallback output to be used when formatting the `*` pattern.
+    bool badSelectOption = !checkSelectOption(*rvVal);
+
     U_ASSERT(U_SUCCESS(status));
     rvVal->selectKeys(adoptedKeys.getAlias(), keysLen, prefsArr, prefsLen,
                       status);
 
+    if (badSelectOption) {
+        context.getErrors().setRecoverableBadOption(rvVal->getFunctionName(), status);
+        CHECK_ERROR(status);
+        // In this case, only the `*` variant should match
+        prefsLen = 0;
+    }
+
     // Update errors
     if (savedStatus != status) {
         if (U_FAILURE(status)) {

icu4c/source/i18n/messageformat2_errors.cpp

@@ -34,7 +34,8 @@ namespace message2 {
     }
 
     void DynamicErrors::setRecoverableBadOption(const FunctionName& formatterName, UErrorCode& status) {
-        addError(DynamicError(DynamicErrorType::RecoverableBadOptionError, formatterName), status);
+        // FIXME: do any tests actually require recoverability?
+        addError(DynamicError(DynamicErrorType::/*Recoverable*/BadOptionError, formatterName), status);
     }
 
     void DynamicErrors::setOperandMismatchError(const FunctionName& formatterName, UErrorCode& status) {

icu4c/source/i18n/messageformat2_evaluation.cpp

@@ -93,7 +93,7 @@ FunctionOptions::FunctionOptions(UVector&& optionsVector, UErrorCode& status) {
 }
 
 // Returns false if option doesn't exist
-UBool FunctionOptions::wasSetFromLiteral(const UnicodeString& key) const {
+UBool FunctionOptions::wasSetFromLiteral(const std::u16string_view key) const {
     if (options == nullptr) {
         U_ASSERT(functionOptionsLen == 0);
     }
@@ -106,7 +106,8 @@ UBool FunctionOptions::wasSetFromLiteral(const UnicodeString& key) const {
     return false;
 }
 
-FunctionOptions::getFunctionOption(const UnicodeString& key,
+const FunctionValue*
+FunctionOptions::getFunctionOption(std::u16string_view key,
                                    UErrorCode& status) const {
     if (options == nullptr) {
         U_ASSERT(functionOptionsLen == 0);
@@ -121,9 +122,8 @@ FunctionOptions::getFunctionOption(const UnicodeString& key,
     return nullptr;
 }
 
-
 UnicodeString
-FunctionOptions::getStringFunctionOption(const UnicodeString& k, UErrorCode& errorCode) const {
+FunctionOptions::getStringFunctionOption(std::u16string_view k, UErrorCode& errorCode) const {
     const FunctionValue* option = getFunctionOption(k, errorCode);
     if (U_SUCCESS(errorCode)) {
         UnicodeString result = option->formatToString(errorCode);
@@ -134,7 +134,7 @@ FunctionOptions::getStringFunctionOption(const UnicodeString& k, UErrorCode& err
     return {};
 }
 
-UnicodeString FunctionOptions::getStringFunctionOption(const UnicodeString& key) const {
+UnicodeString FunctionOptions::getStringFunctionOption(std::u16string_view key) const {
     UErrorCode localStatus = U_ZERO_ERROR;
 
     UnicodeString result = getStringFunctionOption(key, localStatus);
@@ -488,6 +488,7 @@ PrioritizedVariant::~PrioritizedVariant() {}
     // InternalValue
     // -------------
 
+#if false
     InternalValue::InternalValue(FormattedPlaceholder&& arg) {
         argument = std::move(arg);
         selector = nullptr;
@@ -704,6 +705,7 @@ PrioritizedVariant::~PrioritizedVariant() {}
             argument = nullptr;
         }
     }
+#endif
 
 } // namespace message2
 U_NAMESPACE_END

icu4c/source/i18n/messageformat2_formattable.cpp

@@ -172,7 +172,7 @@ namespace message2 {
         return number::NumberFormatter::withLocale(locale).formatDecimal(toFormat, errorCode);
     }
 
-    DateFormat* defaultDateTimeInstance(const Locale& locale, UErrorCode& errorCode) {
+    static DateFormat* defaultDateTimeInstance(const Locale& locale, UErrorCode& errorCode) {
         NULL_ON_ERROR(errorCode);
         LocalPointer<DateFormat> df(DateFormat::createDateTimeInstance(DateFormat::SHORT, DateFormat::SHORT, locale));
         if (!df.isValid()) {
@@ -182,12 +182,34 @@ namespace message2 {
         return df.orphan();
     }
 
-    void formatDateWithDefaults(const Locale& locale, UDate date, UnicodeString& result, UErrorCode& errorCode) {
+    TimeZone* createTimeZone(const DateInfo& dateInfo, UErrorCode& errorCode) {
+        NULL_ON_ERROR(errorCode);
+
+        TimeZone* tz;
+        if (dateInfo.zoneId.isEmpty()) {
+            // Floating time value -- use default time zone
+            tz = TimeZone::createDefault();
+        } else {
+            tz = TimeZone::createTimeZone(dateInfo.zoneId);
+        }
+        if (tz == nullptr) {
+            errorCode = U_MEMORY_ALLOCATION_ERROR;
+        }
+        return tz;
+    }
+
+    void formatDateWithDefaults(const Locale& locale,
+                                const DateInfo& dateInfo,
+                                UnicodeString& result,
+                                UErrorCode& errorCode) {
         CHECK_ERROR(errorCode);
 
         LocalPointer<DateFormat> df(defaultDateTimeInstance(locale, errorCode));
         CHECK_ERROR(errorCode);
-        df->format(date, result, 0, errorCode);
+
+        df->adoptTimeZone(createTimeZone(dateInfo, errorCode));
+        CHECK_ERROR(errorCode);
+        df->format(dateInfo.date, result, nullptr, errorCode);
     }
 
     static UnicodeString& handleBiDi(const Locale& locale,
@@ -245,7 +267,7 @@ namespace message2 {
         case UFMT_DATE: {
             const DateInfo* dateInfo = toFormat.getDate(status);
             U_ASSERT(U_SUCCESS(status));
-            formatDateWithDefaults(locale, d, result, status);
+            formatDateWithDefaults(locale, *dateInfo, result, status);
             break;
         }
         case UFMT_DOUBLE: {