react-native 0.70.6 → 0.71.0-rc.1

package/ReactCommon/react/renderer/components/textinput/androidtextinput/react/renderer/components/androidtextinput/AndroidTextInputProps.cpp

@@ -7,11 +7,11 @@
 
 #include "AndroidTextInputProps.h"
 #include <react/renderer/components/image/conversions.h>
+#include <react/renderer/core/CoreFeatures.h>
 #include <react/renderer/core/propsConversions.h>
 #include <react/renderer/graphics/conversions.h>
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 static bool hasValue(
     const RawProps &rawProps,
@@ -42,219 +42,219 @@ AndroidTextInputProps::AndroidTextInputProps(
     const RawProps &rawProps)
     : ViewProps(context, sourceProps, rawProps),
       BaseTextProps(context, sourceProps, rawProps),
-      autoComplete(convertRawProp(
+      autoComplete(CoreFeatures::enablePropIteratorSetter? sourceProps.autoComplete : convertRawProp(
           context,
           rawProps,
           "autoComplete",
           sourceProps.autoComplete,
           {})),
-      returnKeyLabel(convertRawProp(context, rawProps,
+      returnKeyLabel(CoreFeatures::enablePropIteratorSetter? sourceProps.autoComplete : convertRawProp(context, rawProps,
           "returnKeyLabel",
           sourceProps.returnKeyLabel,
           {})),
-      numberOfLines(convertRawProp(context, rawProps,
+      numberOfLines(CoreFeatures::enablePropIteratorSetter? sourceProps.numberOfLines : convertRawProp(context, rawProps,
           "numberOfLines",
           sourceProps.numberOfLines,
           {0})),
-      disableFullscreenUI(convertRawProp(context, rawProps,
+      disableFullscreenUI(CoreFeatures::enablePropIteratorSetter? sourceProps.disableFullscreenUI : convertRawProp(context, rawProps,
           "disableFullscreenUI",
           sourceProps.disableFullscreenUI,
           {false})),
-      textBreakStrategy(convertRawProp(context, rawProps,
+      textBreakStrategy(CoreFeatures::enablePropIteratorSetter? sourceProps.textBreakStrategy : convertRawProp(context, rawProps,
           "textBreakStrategy",
           sourceProps.textBreakStrategy,
           {})),
-      underlineColorAndroid(convertRawProp(context, rawProps,
+      underlineColorAndroid(CoreFeatures::enablePropIteratorSetter? sourceProps.underlineColorAndroid : convertRawProp(context, rawProps,
           "underlineColorAndroid",
           sourceProps.underlineColorAndroid,
           {})),
-      inlineImageLeft(convertRawProp(context, rawProps,
+      inlineImageLeft(CoreFeatures::enablePropIteratorSetter? sourceProps.inlineImageLeft : convertRawProp(context, rawProps,
           "inlineImageLeft",
           sourceProps.inlineImageLeft,
           {})),
-      inlineImagePadding(convertRawProp(context, rawProps,
+      inlineImagePadding(CoreFeatures::enablePropIteratorSetter? sourceProps.inlineImagePadding : convertRawProp(context, rawProps,
           "inlineImagePadding",
           sourceProps.inlineImagePadding,
           {0})),
-      importantForAutofill(convertRawProp(context, rawProps,
+      importantForAutofill(CoreFeatures::enablePropIteratorSetter? sourceProps.importantForAutofill : convertRawProp(context, rawProps,
           "importantForAutofill",
           sourceProps.importantForAutofill,
           {})),
-      showSoftInputOnFocus(convertRawProp(context, rawProps,
+      showSoftInputOnFocus(CoreFeatures::enablePropIteratorSetter? sourceProps.showSoftInputOnFocus : convertRawProp(context, rawProps,
           "showSoftInputOnFocus",
           sourceProps.showSoftInputOnFocus,
           {false})),
-      autoCapitalize(convertRawProp(context, rawProps,
+      autoCapitalize(CoreFeatures::enablePropIteratorSetter? sourceProps.autoCapitalize : convertRawProp(context, rawProps,
           "autoCapitalize",
           sourceProps.autoCapitalize,
           {})),
-      autoCorrect(convertRawProp(context, rawProps,
+      autoCorrect(CoreFeatures::enablePropIteratorSetter? sourceProps.autoCorrect : convertRawProp(context, rawProps,
           "autoCorrect",
           sourceProps.autoCorrect,
           {false})),
-      autoFocus(convertRawProp(context, rawProps,
+      autoFocus(CoreFeatures::enablePropIteratorSetter? sourceProps.autoFocus : convertRawProp(context, rawProps,
           "autoFocus",
           sourceProps.autoFocus,
           {false})),
-      allowFontScaling(convertRawProp(context, rawProps,
+      allowFontScaling(CoreFeatures::enablePropIteratorSetter? sourceProps.allowFontScaling : convertRawProp(context, rawProps,
           "allowFontScaling",
           sourceProps.allowFontScaling,
           {false})),
-      maxFontSizeMultiplier(convertRawProp(context, rawProps,
+      maxFontSizeMultiplier(CoreFeatures::enablePropIteratorSetter? sourceProps.maxFontSizeMultiplier : convertRawProp(context, rawProps,
           "maxFontSizeMultiplier",
           sourceProps.maxFontSizeMultiplier,
           {0.0})),
-      editable(
+      editable(CoreFeatures::enablePropIteratorSetter? sourceProps.editable :
           convertRawProp(context, rawProps, "editable", sourceProps.editable, {false})),
-      keyboardType(convertRawProp(context, rawProps,
+      keyboardType(CoreFeatures::enablePropIteratorSetter? sourceProps.keyboardType : convertRawProp(context, rawProps,
           "keyboardType",
           sourceProps.keyboardType,
           {})),
-      returnKeyType(convertRawProp(context, rawProps,
+      returnKeyType(CoreFeatures::enablePropIteratorSetter? sourceProps.returnKeyType : convertRawProp(context, rawProps,
           "returnKeyType",
           sourceProps.returnKeyType,
           {})),
-      maxLength(
+      maxLength(CoreFeatures::enablePropIteratorSetter? sourceProps.maxLength :
           convertRawProp(context, rawProps, "maxLength", sourceProps.maxLength, {0})),
-      multiline(convertRawProp(context, rawProps,
+      multiline(CoreFeatures::enablePropIteratorSetter? sourceProps.multiline : convertRawProp(context, rawProps,
           "multiline",
           sourceProps.multiline,
           {false})),
-      placeholder(
+      placeholder(CoreFeatures::enablePropIteratorSetter? sourceProps.placeholder :
           convertRawProp(context, rawProps, "placeholder", sourceProps.placeholder, {})),
-      placeholderTextColor(convertRawProp(context, rawProps,
+      placeholderTextColor(CoreFeatures::enablePropIteratorSetter? sourceProps.placeholderTextColor : convertRawProp(context, rawProps,
           "placeholderTextColor",
           sourceProps.placeholderTextColor,
           {})),
-      secureTextEntry(convertRawProp(context, rawProps,
+      secureTextEntry(CoreFeatures::enablePropIteratorSetter? sourceProps.secureTextEntry : convertRawProp(context, rawProps,
           "secureTextEntry",
           sourceProps.secureTextEntry,
           {false})),
-      selectionColor(convertRawProp(context, rawProps,
+      selectionColor(CoreFeatures::enablePropIteratorSetter? sourceProps.selectionColor : convertRawProp(context, rawProps,
           "selectionColor",
           sourceProps.selectionColor,
           {})),
-      selection(
+      selection(CoreFeatures::enablePropIteratorSetter? sourceProps.selection :
           convertRawProp(context, rawProps, "selection", sourceProps.selection, {})),
-      value(convertRawProp(context, rawProps, "value", sourceProps.value, {})),
-      defaultValue(convertRawProp(context, rawProps,
+      value(CoreFeatures::enablePropIteratorSetter? sourceProps.value : convertRawProp(context, rawProps, "value", sourceProps.value, {})),
+      defaultValue(CoreFeatures::enablePropIteratorSetter? sourceProps.defaultValue : convertRawProp(context, rawProps,
           "defaultValue",
           sourceProps.defaultValue,
           {})),
-      selectTextOnFocus(convertRawProp(context, rawProps,
+      selectTextOnFocus(CoreFeatures::enablePropIteratorSetter? sourceProps.selectTextOnFocus : convertRawProp(context, rawProps,
           "selectTextOnFocus",
           sourceProps.selectTextOnFocus,
           {false})),
-      blurOnSubmit(convertRawProp(context, rawProps,
-          "blurOnSubmit",
-          sourceProps.blurOnSubmit,
-          {false})),
-      caretHidden(convertRawProp(context, rawProps,
+      submitBehavior(CoreFeatures::enablePropIteratorSetter? sourceProps.submitBehavior : convertRawProp(context, rawProps,
+           "submitBehavior",
+          sourceProps.submitBehavior,
+          {})),
+      caretHidden(CoreFeatures::enablePropIteratorSetter? sourceProps.caretHidden : convertRawProp(context, rawProps,
           "caretHidden",
           sourceProps.caretHidden,
           {false})),
-      contextMenuHidden(convertRawProp(context, rawProps,
+      contextMenuHidden(CoreFeatures::enablePropIteratorSetter? sourceProps.contextMenuHidden : convertRawProp(context, rawProps,
           "contextMenuHidden",
           sourceProps.contextMenuHidden,
           {false})),
-      textShadowColor(convertRawProp(context, rawProps,
+      textShadowColor(CoreFeatures::enablePropIteratorSetter? sourceProps.textShadowColor : convertRawProp(context, rawProps,
           "textShadowColor",
           sourceProps.textShadowColor,
           {})),
-      textShadowRadius(convertRawProp(context, rawProps,
+      textShadowRadius(CoreFeatures::enablePropIteratorSetter? sourceProps.textShadowRadius : convertRawProp(context, rawProps,
           "textShadowRadius",
           sourceProps.textShadowRadius,
           {0.0})),
-      textDecorationLine(convertRawProp(context, rawProps,
+      textDecorationLine(CoreFeatures::enablePropIteratorSetter? sourceProps.textDecorationLine : convertRawProp(context, rawProps,
           "textDecorationLine",
           sourceProps.textDecorationLine,
           {})),
-      fontStyle(
+      fontStyle(CoreFeatures::enablePropIteratorSetter? sourceProps.fontStyle :
           convertRawProp(context, rawProps, "fontStyle", sourceProps.fontStyle, {})),
-      textShadowOffset(convertRawProp(context, rawProps,
+      textShadowOffset(CoreFeatures::enablePropIteratorSetter? sourceProps.textShadowOffset : convertRawProp(context, rawProps,
           "textShadowOffset",
           sourceProps.textShadowOffset,
           {})),
-      lineHeight(convertRawProp(context, rawProps,
+      lineHeight(CoreFeatures::enablePropIteratorSetter? sourceProps.lineHeight : convertRawProp(context, rawProps,
           "lineHeight",
           sourceProps.lineHeight,
           {0.0})),
-      textTransform(convertRawProp(context, rawProps,
+      textTransform(CoreFeatures::enablePropIteratorSetter? sourceProps.textTransform : convertRawProp(context, rawProps,
           "textTransform",
           sourceProps.textTransform,
           {})),
       color(0 /*convertRawProp(context, rawProps, "color", sourceProps.color, {0})*/),
-      letterSpacing(convertRawProp(context, rawProps,
+      letterSpacing(CoreFeatures::enablePropIteratorSetter? sourceProps.letterSpacing : convertRawProp(context, rawProps,
           "letterSpacing",
           sourceProps.letterSpacing,
           {0.0})),
-      fontSize(
+      fontSize(CoreFeatures::enablePropIteratorSetter? sourceProps.fontSize :
           convertRawProp(context, rawProps, "fontSize", sourceProps.fontSize, {0.0})),
-      textAlign(
+      textAlign(CoreFeatures::enablePropIteratorSetter? sourceProps.textAlign :
           convertRawProp(context, rawProps, "textAlign", sourceProps.textAlign, {})),
-      includeFontPadding(convertRawProp(context, rawProps,
+      includeFontPadding(CoreFeatures::enablePropIteratorSetter? sourceProps.includeFontPadding : convertRawProp(context, rawProps,
           "includeFontPadding",
           sourceProps.includeFontPadding,
           {false})),
-      fontWeight(
+      fontWeight(CoreFeatures::enablePropIteratorSetter? sourceProps.fontWeight :
           convertRawProp(context, rawProps, "fontWeight", sourceProps.fontWeight, {})),
-      fontFamily(
+      fontFamily(CoreFeatures::enablePropIteratorSetter? sourceProps.fontFamily :
           convertRawProp(context, rawProps, "fontFamily", sourceProps.fontFamily, {})),
-      textAlignVertical(convertRawProp(context, rawProps,
+      textAlignVertical(CoreFeatures::enablePropIteratorSetter? sourceProps.textAlignVertical : convertRawProp(context, rawProps,
           "textAlignVertical",
           sourceProps.textAlignVertical,
           {})),
-      cursorColor(
+      cursorColor(CoreFeatures::enablePropIteratorSetter? sourceProps.cursorColor :
           convertRawProp(context, rawProps, "cursorColor", sourceProps.cursorColor, {})),
-      mostRecentEventCount(convertRawProp(context, rawProps,
+      mostRecentEventCount(CoreFeatures::enablePropIteratorSetter? sourceProps.mostRecentEventCount : convertRawProp(context, rawProps,
           "mostRecentEventCount",
           sourceProps.mostRecentEventCount,
           {0})),
-      text(convertRawProp(context, rawProps, "text", sourceProps.text, {})),
-      paragraphAttributes(
+      text(CoreFeatures::enablePropIteratorSetter? sourceProps.text : convertRawProp(context, rawProps, "text", sourceProps.text, {})),
+      paragraphAttributes(CoreFeatures::enablePropIteratorSetter? sourceProps.paragraphAttributes :
           convertRawProp(context, rawProps, sourceProps.paragraphAttributes, {})),
       // See AndroidTextInputComponentDescriptor for usage
       // TODO T63008435: can these, and this feature, be removed entirely?
-      hasPadding(hasValue(rawProps, sourceProps.hasPadding, "", "padding", "")),
-      hasPaddingHorizontal(hasValue(
+      hasPadding(CoreFeatures::enablePropIteratorSetter? sourceProps.hasPadding : hasValue(rawProps, sourceProps.hasPadding, "", "padding", "")),
+      hasPaddingHorizontal(CoreFeatures::enablePropIteratorSetter? sourceProps.hasPaddingHorizontal : hasValue(
           rawProps,
           sourceProps.hasPaddingHorizontal,
           "Horizontal",
           "padding",
           "")),
-      hasPaddingVertical(hasValue(
+      hasPaddingVertical(CoreFeatures::enablePropIteratorSetter? sourceProps.hasPaddingVertical : hasValue(
           rawProps,
           sourceProps.hasPaddingVertical,
           "Vertical",
           "padding",
           "")),
-      hasPaddingLeft(hasValue(
+      hasPaddingLeft(CoreFeatures::enablePropIteratorSetter? sourceProps.hasPaddingLeft : hasValue(
           rawProps,
           sourceProps.hasPaddingLeft,
           "Left",
           "padding",
           "")),
-      hasPaddingTop(
+      hasPaddingTop(CoreFeatures::enablePropIteratorSetter? sourceProps.hasPaddingTop :
           hasValue(rawProps, sourceProps.hasPaddingTop, "Top", "padding", "")),
-      hasPaddingRight(hasValue(
+      hasPaddingRight(CoreFeatures::enablePropIteratorSetter? sourceProps.hasPaddingRight : hasValue(
           rawProps,
           sourceProps.hasPaddingRight,
           "Right",
           "padding",
           "")),
-      hasPaddingBottom(hasValue(
+      hasPaddingBottom(CoreFeatures::enablePropIteratorSetter? sourceProps.hasPaddingBottom : hasValue(
           rawProps,
           sourceProps.hasPaddingBottom,
           "Bottom",
           "padding",
           "")),
-      hasPaddingStart(hasValue(
+      hasPaddingStart(CoreFeatures::enablePropIteratorSetter? sourceProps.hasPaddingStart : hasValue(
           rawProps,
           sourceProps.hasPaddingStart,
           "Start",
           "padding",
           "")),
-      hasPaddingEnd(
+      hasPaddingEnd(CoreFeatures::enablePropIteratorSetter? sourceProps.hasPaddingEnd :
           hasValue(rawProps, sourceProps.hasPaddingEnd, "End", "padding", "")) {
 }
 
@@ -263,8 +263,157 @@ void AndroidTextInputProps::setProp(
     RawPropsPropNameHash hash,
     const char *propName,
     RawValue const &value) {
+  // All Props structs setProp methods must always, unconditionally,
+  // call all super::setProp methods, since multiple structs may
+  // reuse the same values.
   ViewProps::setProp(context, hash, propName, value);
   BaseTextProps::setProp(context, hash, propName, value);
+
+  // ParagraphAttributes has its own switch statement - to keep all
+  // of these fields together, and because there are some collisions between
+  // propnames parsed here and outside of ParagraphAttributes. For example,
+  // textBreakStrategy is duplicated.
+  // This code is also duplicated in ParagraphProps.
+  static auto paDefaults = ParagraphAttributes{};
+  switch (hash) {
+    REBUILD_FIELD_SWITCH_CASE(
+        paDefaults,
+        value,
+        paragraphAttributes,
+        maximumNumberOfLines,
+        "numberOfLines");
+    REBUILD_FIELD_SWITCH_CASE(
+        paDefaults, value, paragraphAttributes, ellipsizeMode, "ellipsizeMode");
+    REBUILD_FIELD_SWITCH_CASE(
+        paDefaults,
+        value,
+        paragraphAttributes,
+        textBreakStrategy,
+        "textBreakStrategy");
+    REBUILD_FIELD_SWITCH_CASE(
+        paDefaults,
+        value,
+        paragraphAttributes,
+        adjustsFontSizeToFit,
+        "adjustsFontSizeToFit");
+    REBUILD_FIELD_SWITCH_CASE(
+        paDefaults,
+        value,
+        paragraphAttributes,
+        minimumFontSize,
+        "minimumFontSize");
+    REBUILD_FIELD_SWITCH_CASE(
+        paDefaults,
+        value,
+        paragraphAttributes,
+        maximumFontSize,
+        "maximumFontSize");
+    REBUILD_FIELD_SWITCH_CASE(
+        paDefaults,
+        value,
+        paragraphAttributes,
+        includeFontPadding,
+        "includeFontPadding");
+    REBUILD_FIELD_SWITCH_CASE(
+        paDefaults,
+        value,
+        paragraphAttributes,
+        android_hyphenationFrequency,
+        "android_hyphenationFrequency");
+  }
+
+  switch (hash) {
+    RAW_SET_PROP_SWITCH_CASE_BASIC(autoComplete, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(returnKeyLabel, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(numberOfLines, 0);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(disableFullscreenUI, false);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(textBreakStrategy, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(underlineColorAndroid, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(inlineImageLeft, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(inlineImagePadding, 0);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(importantForAutofill, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(showSoftInputOnFocus, false);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(autoCapitalize, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(autoCorrect, false);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(autoFocus, false);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(allowFontScaling, false);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(maxFontSizeMultiplier, (Float)0.0);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(editable, false);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(keyboardType, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(returnKeyType, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(maxLength, 0);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(multiline, false);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(placeholder, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(placeholderTextColor, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(secureTextEntry, false);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(selectionColor, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(selection, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(this->value, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(defaultValue, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(selectTextOnFocus, false);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(submitBehavior, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(caretHidden, false);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(contextMenuHidden, false);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(textShadowColor, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(textShadowRadius, (Float)0.0);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(textDecorationLine, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(fontStyle, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(textShadowOffset, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(lineHeight, (Float)0.0);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(textTransform, {});
+    // RAW_SET_PROP_SWITCH_CASE_BASIC(color, {0}); // currently not being parsed
+    RAW_SET_PROP_SWITCH_CASE_BASIC(letterSpacing, (Float)0.0);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(fontSize, (Float)0.0);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(textAlign, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(includeFontPadding, false);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(fontWeight, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(fontFamily, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(textAlignVertical, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(cursorColor, {});
+    RAW_SET_PROP_SWITCH_CASE_BASIC(mostRecentEventCount, 0);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(text, {});
+
+    // Paddings are not parsed at this level of the component (they're parsed in
+    // ViewProps) but we do need to know if they're present or not. See
+    // AndroidTextInputComponentDescriptor for usage
+    // TODO T63008435: can these, and this feature, be removed entirely?
+    case CONSTEXPR_RAW_PROPS_KEY_HASH("padding"): {
+      hasPadding = value.hasValue();
+      return;
+    }
+    case CONSTEXPR_RAW_PROPS_KEY_HASH("paddingHorizontal"): {
+      hasPaddingHorizontal = value.hasValue();
+      return;
+    }
+    case CONSTEXPR_RAW_PROPS_KEY_HASH("paddingVertical"): {
+      hasPaddingVertical = value.hasValue();
+      return;
+    }
+    case CONSTEXPR_RAW_PROPS_KEY_HASH("paddingLeft"): {
+      hasPaddingLeft = value.hasValue();
+      return;
+    }
+    case CONSTEXPR_RAW_PROPS_KEY_HASH("paddingRight"): {
+      hasPaddingRight = value.hasValue();
+      return;
+    }
+    case CONSTEXPR_RAW_PROPS_KEY_HASH("paddingTop"): {
+      hasPaddingTop = value.hasValue();
+      return;
+    }
+    case CONSTEXPR_RAW_PROPS_KEY_HASH("paddingBottom"): {
+      hasPaddingBottom = value.hasValue();
+      return;
+    }
+    case CONSTEXPR_RAW_PROPS_KEY_HASH("paddingStart"): {
+      hasPaddingStart = value.hasValue();
+      return;
+    }
+    case CONSTEXPR_RAW_PROPS_KEY_HASH("paddingEnd"): {
+      hasPaddingEnd = value.hasValue();
+      return;
+    }
+  }
 }
 
 // TODO T53300085: support this in codegen; this was hand-written
@@ -298,7 +447,7 @@ folly::dynamic AndroidTextInputProps::getDynamic() const {
   props["value"] = value;
   props["defaultValue"] = defaultValue;
   props["selectTextOnFocus"] = selectTextOnFocus;
-  props["blurOnSubmit"] = blurOnSubmit;
+  props["submitBehavior"] = submitBehavior;
   props["caretHidden"] = caretHidden;
   props["contextMenuHidden"] = contextMenuHidden;
   props["textShadowColor"] = toAndroidRepr(textShadowColor);
@@ -342,5 +491,4 @@ SharedDebugStringConvertibleList AndroidTextInputProps::getDebugProps() const {
 }
 #endif
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

package/ReactCommon/react/renderer/components/textinput/androidtextinput/react/renderer/components/androidtextinput/AndroidTextInputProps.h

@@ -115,76 +115,76 @@ class AndroidTextInputProps final : public ViewProps, public BaseTextProps {
 
 #pragma mark - Props
 
-  const std::string autoComplete{};
-  const std::string returnKeyLabel{};
-  const int numberOfLines{0};
-  const bool disableFullscreenUI{false};
-  const std::string textBreakStrategy{};
-  const SharedColor underlineColorAndroid{};
-  const std::string inlineImageLeft{};
-  const int inlineImagePadding{0};
-  const std::string importantForAutofill{};
-  const bool showSoftInputOnFocus{false};
-  const std::string autoCapitalize{};
-  const bool autoCorrect{false};
-  const bool autoFocus{false};
-  const bool allowFontScaling{false};
-  const Float maxFontSizeMultiplier{0.0};
-  const bool editable{false};
-  const std::string keyboardType{};
-  const std::string returnKeyType{};
-  const int maxLength{0};
-  const bool multiline{false};
-  const std::string placeholder{};
-  const SharedColor placeholderTextColor{};
-  const bool secureTextEntry{false};
-  const SharedColor selectionColor{};
-  const AndroidTextInputSelectionStruct selection{};
-  const std::string value{};
-  const std::string defaultValue{};
-  const bool selectTextOnFocus{false};
-  const bool blurOnSubmit{false};
-  const bool caretHidden{false};
-  const bool contextMenuHidden{false};
-  const SharedColor textShadowColor{};
-  const Float textShadowRadius{0.0};
-  const std::string textDecorationLine{};
-  const std::string fontStyle{};
-  const AndroidTextInputTextShadowOffsetStruct textShadowOffset{};
-  const Float lineHeight{0.0};
-  const std::string textTransform{};
-  const SharedColor color{0};
-  const Float letterSpacing{0.0};
-  const Float fontSize{0.0};
-  const std::string textAlign{};
-  const bool includeFontPadding{false};
-  const std::string fontWeight{};
-  const std::string fontFamily{};
-  const std::string textAlignVertical{};
-  const SharedColor cursorColor{};
-  const int mostRecentEventCount{0};
-  const std::string text{};
+  std::string autoComplete{};
+  std::string returnKeyLabel{};
+  int numberOfLines{0};
+  bool disableFullscreenUI{false};
+  std::string textBreakStrategy{};
+  SharedColor underlineColorAndroid{};
+  std::string inlineImageLeft{};
+  int inlineImagePadding{0};
+  std::string importantForAutofill{};
+  bool showSoftInputOnFocus{false};
+  std::string autoCapitalize{};
+  bool autoCorrect{false};
+  bool autoFocus{false};
+  bool allowFontScaling{false};
+  Float maxFontSizeMultiplier{0.0};
+  bool editable{false};
+  std::string keyboardType{};
+  std::string returnKeyType{};
+  int maxLength{0};
+  bool multiline{false};
+  std::string placeholder{};
+  SharedColor placeholderTextColor{};
+  bool secureTextEntry{false};
+  SharedColor selectionColor{};
+  AndroidTextInputSelectionStruct selection{};
+  std::string value{};
+  std::string defaultValue{};
+  bool selectTextOnFocus{false};
+  std::string submitBehavior{};
+  bool caretHidden{false};
+  bool contextMenuHidden{false};
+  SharedColor textShadowColor{};
+  Float textShadowRadius{0.0};
+  std::string textDecorationLine{};
+  std::string fontStyle{};
+  AndroidTextInputTextShadowOffsetStruct textShadowOffset{};
+  Float lineHeight{0.0};
+  std::string textTransform{};
+  SharedColor color{0};
+  Float letterSpacing{0.0};
+  Float fontSize{0.0};
+  std::string textAlign{};
+  bool includeFontPadding{false};
+  std::string fontWeight{};
+  std::string fontFamily{};
+  std::string textAlignVertical{};
+  SharedColor cursorColor{};
+  int mostRecentEventCount{0};
+  std::string text{};
 
   /*
    * Contains all prop values that affect visual representation of the
    * paragraph.
    */
-  ParagraphAttributes const paragraphAttributes{};
+  ParagraphAttributes paragraphAttributes{};
 
   /**
    * Auxiliary information to detect if these props are set or not.
    * See AndroidTextInputComponentDescriptor for usage.
    * TODO T63008435: can these, and this feature, be removed entirely?
    */
-  const bool hasPadding{};
-  const bool hasPaddingHorizontal{};
-  const bool hasPaddingVertical{};
-  const bool hasPaddingLeft{};
-  const bool hasPaddingTop{};
-  const bool hasPaddingRight{};
-  const bool hasPaddingBottom{};
-  const bool hasPaddingStart{};
-  const bool hasPaddingEnd{};
+  bool hasPadding{};
+  bool hasPaddingHorizontal{};
+  bool hasPaddingVertical{};
+  bool hasPaddingLeft{};
+  bool hasPaddingTop{};
+  bool hasPaddingRight{};
+  bool hasPaddingBottom{};
+  bool hasPaddingStart{};
+  bool hasPaddingEnd{};
 
 #if RN_DEBUG_STRING_CONVERTIBLE
   SharedDebugStringConvertibleList getDebugProps() const;

package/ReactCommon/react/renderer/components/textinput/androidtextinput/react/renderer/components/androidtextinput/AndroidTextInputShadowNode.cpp

@@ -21,8 +21,7 @@
 
 using namespace facebook::jni;
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 extern const char AndroidTextInputComponentName[] = "AndroidTextInput";
 
@@ -141,17 +140,17 @@ void AndroidTextInputShadowNode::updateStateIfNeeded() {
   auto defaultTextAttributes = TextAttributes::defaultTextAttributes();
   defaultTextAttributes.apply(getConcreteProps().textAttributes);
 
-  auto newEventCount =
-      (state.reactTreeAttributedString == reactTreeAttributedString
-           ? 0
-           : getConcreteProps().mostRecentEventCount);
-  auto newAttributedString = getMostRecentAttributedString();
-
   // Even if we're here and updating state, it may be only to update the layout
   // manager If that is the case, make sure we don't update text: pass in the
   // current attributedString unchanged, and pass in zero for the "event count"
   // so no changes are applied There's no way to prevent a state update from
   // flowing to Java, so we just ensure it's a noop in those cases.
+  auto newEventCount =
+      state.reactTreeAttributedString.isContentEqual(reactTreeAttributedString)
+      ? 0
+      : getConcreteProps().mostRecentEventCount;
+  auto newAttributedString = getMostRecentAttributedString();
+
   setStateData(AndroidTextInputState{
       newEventCount,
       newAttributedString,
@@ -168,7 +167,7 @@ void AndroidTextInputShadowNode::updateStateIfNeeded() {
 #pragma mark - LayoutableShadowNode
 
 Size AndroidTextInputShadowNode::measureContent(
-    LayoutContext const &layoutContext,
+    LayoutContext const & /*layoutContext*/,
     LayoutConstraints const &layoutConstraints) const {
   if (getStateData().cachedAttributedStringId != 0) {
     return textLayoutManager_
@@ -207,5 +206,4 @@ void AndroidTextInputShadowNode::layout(LayoutContext layoutContext) {
   ConcreteViewShadowNode::layout(layoutContext);
 }
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react