Note: This document covers API impact only. For more details, see the ABI compatibility page

Remove union member

Overview

- init step 1 step 2 step 3
fidl link link
dart link link link
go link link link
hlcpp link link link
llcpp link link link
rust link link link

Initial State {#init}

FIDL {#fidl-init}

  1. flexible union JsonValue {
  2.     1: int32 int_value;
  3.     2: string:MAX string_value;
  4.     3: float32 float_value;
  5. };

Dart {#dart-init}

  1. fidllib.JsonValue writer(String s) {
  2.   final asFloat = double.tryParse(s);
  3.   if (asFloat != null) {
  4.     return fidllib.JsonValue.withFloatValue(asFloat);
  5.   }
  6.   final asInt = int.tryParse(s);
  7.   if (asInt != null) {
  8.     return fidllib.JsonValue.withIntValue(asInt);
  9.   }
  10.   return fidllib.JsonValue.withStringValue(s);
  11. }
  13. String reader(fidllib.JsonValue value) {
  14.   switch (value.$tag) {
  15.     case fidllib.JsonValueTag.intValue:
  16.       return '${value.intValue}';
  17.     case fidllib.JsonValueTag.stringValue:
  18.       return value.stringValue;
  19.     case fidllib.JsonValueTag.floatValue:
  20.       return '${value.floatValue}';
  21.     default:
  22.       return '<${value.$unknownData.data.length} unknown bytes>';
  23.   }
  24. }

Go {#go-init}

  1. func writer(s string) lib.JsonValue {
  2.     n, err := strconv.ParseInt(s, 10, 32)
  3.     if err == nil {
  4.         return lib.JsonValueWithIntValue(int32(n))
  5.     }
  6.     var f float64
  7.     f, err = strconv.ParseFloat(s, 64)
  8.     if err == nil {
  9.         return lib.JsonValueWithFloatValue(float32(f))
  10.     }
  11.     return lib.JsonValueWithStringValue(s)
  12. }
  14. func reader(value lib.JsonValue) string {
  15.     switch value.Which() {
  16.     case lib.JsonValueIntValue:
  17.         return fmt.Sprintf("%d", value.IntValue)
  18.     case lib.JsonValueStringValue:
  19.         return value.StringValue
  20.     case lib.JsonValueFloatValue:
  21.         return fmt.Sprintf("%f", value.FloatValue)
  22.     default:
  23.         return fmt.Sprintf("<%d unknown bytes>", len(value.GetUnknownData().Bytes))
  24.     }
  25. }

HLCPP {#hlcpp-init}

  1. fidl_test::JsonValue writer(const std::string& s) {
  2.   std::optional<float> maybe_float = parse_as_float(s);
  3.   if (maybe_float) {
  4.     return fidl_test::JsonValue::WithFloatValue(std::move(*maybe_float));
  5.   }
  7.   std::optional<int32_t> maybe_int = parse_as_int(s);
  8.   if (maybe_int) {
  9.     return fidl_test::JsonValue::WithIntValue(std::move(*maybe_int));
  10.   }
  11.   auto val = s;
  12.   return fidl_test::JsonValue::WithStringValue(std::move(val));
  13. }
  15. std::string reader(const fidl_test::JsonValue& value) {
  16.   switch (value.Which()) {
  17.     case fidl_test::JsonValue::Tag::kIntValue:
  18.       return std::to_string(value.int_value());
  19.     case fidl_test::JsonValue::Tag::kStringValue:
  20.       return value.string_value();
  21.     case fidl_test::JsonValue::Tag::kFloatValue:
  22.       return std::to_string(value.float_value());
  23.     case fidl_test::JsonValue::Tag::Invalid:
  24.       return "<uninitialized>";
  25.     case fidl_test::JsonValue::Tag::kUnknown: {
  26.       std::ostringstream out;
  27.       out << "<" << value.UnknownBytes()->size() << " unknown bytes>";
  28.       return out.str();
  29.     }
  30.   }
  31. }

LLCPP {#llcpp-init}

  1. fidl_test::JsonValue writer(const std::string& s) {
  2.   std::optional<float> maybe_float = parse_as_float(s);
  3.   ;
  4.   if (maybe_float) {
  5.     return fidl_test::JsonValue::WithIntValue(std::make_unique<int32_t>(*maybe_float));
  6.   }
  7.   std::optional<int32_t> maybe_int = parse_as_int(s);
  8.   if (maybe_int) {
  9.     return fidl_test::JsonValue::WithIntValue(std::make_unique<int32_t>(*maybe_int));
  10.   }
  11.   return fidl_test::JsonValue::WithStringValue(
  12.       std::make_unique<fidl::StringView>(fidl::heap_copy_str(s)));
  13. }
  15. std::string reader(const fidl_test::JsonValue& value) {
  16.   switch (value.which()) {
  17.     case fidl_test::JsonValue::Tag::kIntValue:
  18.       return std::to_string(value.int_value());
  19.     case fidl_test::JsonValue::Tag::kStringValue:
  20.       return std::string(value.string_value().data(), value.string_value().size());
  21.     case fidl_test::JsonValue::Tag::kFloatValue:
  22.       return std::to_string(value.float_value());
  23.     case fidl_test::JsonValue::Tag::kUnknown:
  24.       return "<unknown>";
  25.   }
  26. }

Rust {#rust-init}

  1. fn writer(s: &str) -> fidl_lib::JsonValue {
  2.     let as_float = s.parse::<f32>();
  3.     if let Ok(val) = as_float {
  4.         return fidl_lib::JsonValue::FloatValue(val);
  5.     }
  6.     let as_int = s.parse::<i32>();
  7.     as_int
  8.         .map(|n| fidl_lib::JsonValue::IntValue(n))
  9.         .unwrap_or(fidl_lib::JsonValue::StringValue(s.to_string()))
  10. }
  12. fn reader(value: fidl_lib::JsonValue) -> String {
  13.     match value {
  14.         fidl_lib::JsonValue::IntValue(n) => format!("{}", n),
  15.         fidl_lib::JsonValue::StringValue(s) => s,
  16.         fidl_lib::JsonValue::FloatValue(v) => format!("{:.2}", v),
  17.         fidl_lib::JsonValueUnknown!() => "<unknown>".to_string(),
  18.     }
  19. }

Update Source Code {#step-1}

Dart {#dart-1}

  • Update writers to stop producing new instances of the soon-to-be-removed variant.
  • Remove references to the soon-to-be-removed variant from any switch statements on the union tag. These must be temporarily handled as part of a default case.
  1.   fidllib.JsonValue writer(String s) {
  2. -   final asFloat = double.tryParse(s);
  3. -   if (asFloat != null) {
  4. -     return fidllib.JsonValue.withFloatValue(asFloat);
  5. -   }
  6.     final asInt = int.tryParse(s);
  7.     if (asInt != null) {
  8.       return fidllib.JsonValue.withIntValue(asInt);
  9.     }
  10.     return fidllib.JsonValue.withStringValue(s);
  11.   }
  13.   String reader(fidllib.JsonValue value) {
  14.     switch (value.$tag) {
  15.       case fidllib.JsonValueTag.intValue:
  16.         return '${value.intValue}';
  17.       case fidllib.JsonValueTag.stringValue:
  18.         return value.stringValue;
  19. -     case fidllib.JsonValueTag.floatValue:
  20. -       return '${value.floatValue}';
  21. +     case fidllib.JsonValueTag.$unknown:
  22. +       return '<${value.$unknownData.data.length} unknown bytes>';
  23.       default:
  24. -       return '<${value.$unknownData.data.length} unknown bytes>';
  25. +       return '<unknown new member>';
  26.     }
  27.   }

Go {#go-1}

  • Update writers to stop producing new instances of the soon-to-be-removed variant.
  • Remove references to the soon-to-be-removed variant from any switch statements on the union tag. These must be temporarily handled as part of a default case.
  1.   func writer(s string) lib.JsonValue {
  2.       n, err := strconv.ParseInt(s, 10, 32)
  3.       if err == nil {
  4.           return lib.JsonValueWithIntValue(int32(n))
  5. -     }
  6. -     var f float64
  7. -     f, err = strconv.ParseFloat(s, 64)
  8. -     if err == nil {
  9. -         return lib.JsonValueWithFloatValue(float32(f))
  10.       }
  11.       return lib.JsonValueWithStringValue(s)
  12.   }
  14.   func reader(value lib.JsonValue) string {
  15.       switch value.Which() {
  16.       case lib.JsonValueIntValue:
  17.           return fmt.Sprintf("%d", value.IntValue)
  18.       case lib.JsonValueStringValue:
  19.           return value.StringValue
  20. -     case lib.JsonValueFloatValue:
  21. -         return fmt.Sprintf("%f", value.FloatValue)
  22. +     case lib.JsonValue_unknownData:
  23. +         return fmt.Sprintf("<%d unknown bytes>", len(value.GetUnknownData().Bytes))
  24.       default:
  25. -         return fmt.Sprintf("<%d unknown bytes>", len(value.GetUnknownData().Bytes))
  26. +         return "<unknown new member>"
  27.       }
  28.   }

HLCPP {#hlcpp-1}

  • Update writers to stop producing new instances of the soon-to-be-removed variant.
  • Remove references to the soon-to-be-removed variant from any switch statements on the union tag. These must be temporarily handled as part of a default case.
  1.   fidl_test::JsonValue writer(const std::string& s) {
  2. -   std::optional<float> maybe_float = parse_as_float(s);
  3. -   if (maybe_float) {
  4. -     return fidl_test::JsonValue::WithFloatValue(std::move(*maybe_float));
  5. -   }
  6. - 
  7.     std::optional<int32_t> maybe_int = parse_as_int(s);
  8.     if (maybe_int) {
  9.       return fidl_test::JsonValue::WithIntValue(std::move(*maybe_int));
  10.     }
  11.     auto val = s;
  12.     return fidl_test::JsonValue::WithStringValue(std::move(val));
  13.   }
  15.   std::string reader(const fidl_test::JsonValue& value) {
  16.     switch (value.Which()) {
  17.       case fidl_test::JsonValue::Tag::kIntValue:
  18.         return std::to_string(value.int_value());
  19.       case fidl_test::JsonValue::Tag::kStringValue:
  20.         return value.string_value();
  21. -     case fidl_test::JsonValue::Tag::kFloatValue:
  22. -       return std::to_string(value.float_value());
  23.       case fidl_test::JsonValue::Tag::Invalid:
  24.         return "<uninitialized>";
  25.       case fidl_test::JsonValue::Tag::kUnknown: {
  26.         std::ostringstream out;
  27.         out << "<" << value.UnknownBytes()->size() << " unknown bytes>";
  28.         return out.str();
  29.       }
  30. +     default:
  31. +       return "<unknown new member>";
  32.     }
  33.   }

LLCPP {#llcpp-1}

  • Update writers to stop producing new instances of the soon-to-be-removed variant.
  • Remove references to the soon-to-be-removed variant from any switch statements on the union tag. These must be temporarily handled as part of a default case.
  1.   fidl_test::JsonValue writer(const std::string& s) {
  2. -   std::optional<float> maybe_float = parse_as_float(s);
  3. -   ;
  4. -   if (maybe_float) {
  5. -     return fidl_test::JsonValue::WithIntValue(std::make_unique<int32_t>(*maybe_float));
  6. -   }
  7.     std::optional<int32_t> maybe_int = parse_as_int(s);
  8.     if (maybe_int) {
  9.       return fidl_test::JsonValue::WithIntValue(std::make_unique<int32_t>(*maybe_int));
  10.     }
  11.     return fidl_test::JsonValue::WithStringValue(
  12.         std::make_unique<fidl::StringView>(fidl::heap_copy_str(s)));
  13.   }
  15.   std::string reader(const fidl_test::JsonValue& value) {
  16.     switch (value.which()) {
  17.       case fidl_test::JsonValue::Tag::kIntValue:
  18.         return std::to_string(value.int_value());
  19.       case fidl_test::JsonValue::Tag::kStringValue:
  20.         return std::string(value.string_value().data(), value.string_value().size());
  21. -     case fidl_test::JsonValue::Tag::kFloatValue:
  22. -       return std::to_string(value.float_value());
  23.       case fidl_test::JsonValue::Tag::kUnknown:
  24. +     default:
  25.         return "<unknown>";
  26.     }
  27.   }

Rust {#rust-1}

  • Update writers to stop producing new instances of the soon-to-be-removed variant.
  • Remove references to the soon-to-be-removed variant from any match statements on the union. These must be temporarily handled as part of a default catch-all case.
  1.   fn writer(s: &str) -> fidl_lib::JsonValue {
  2. -     let as_float = s.parse::<f32>();
  3. -     if let Ok(val) = as_float {
  4. -         return fidl_lib::JsonValue::FloatValue(val);
  5. -     }
  6.       let as_int = s.parse::<i32>();
  7.       as_int
  8.           .map(|n| fidl_lib::JsonValue::IntValue(n))
  9.           .unwrap_or(fidl_lib::JsonValue::StringValue(s.to_string()))
  10.   }
  12.   fn reader(value: fidl_lib::JsonValue) -> String {
  13.       match value {
  14.           fidl_lib::JsonValue::IntValue(n) => format!("{}", n),
  15.           fidl_lib::JsonValue::StringValue(s) => s,
  16. -         fidl_lib::JsonValue::FloatValue(v) => format!("{:.2}", v),
  17. -         fidl_lib::JsonValueUnknown!() => "<unknown>".to_string(),
  18. +         _ => "<unknown>".to_string(),
  19.       }
  20.   }

Update FIDL Library {#step-2}

  • Remove the union variant
  1.   flexible union JsonValue {
  2.       1: int32 int_value;
  3.       2: string:MAX string_value;
  4. -     3: float32 float_value;
  5.   };

Update Source Code {#step-3}

Dart {#dart-3}

  • The default case can now be removed from any switch statements on the union tag.
  1.     if (asInt != null) {
  2.       return fidllib.JsonValue.withIntValue(asInt);
  3.     }
  4.     return fidllib.JsonValue.withStringValue(s);
  5.   }
  7.   String reader(fidllib.JsonValue value) {
  8.     switch (value.$tag) {
  9.       case fidllib.JsonValueTag.intValue:
  10.         return '${value.intValue}';
  11.       case fidllib.JsonValueTag.stringValue:
  12.         return value.stringValue;
  13. -     case fidllib.JsonValueTag.$unknown:
  14. +     default:
  15.         return '<${value.$unknownData.data.length} unknown bytes>';
  16. -     default:
  17. -       return '<unknown new member>';
  18.     }
  19.   }

Go {#go-3}

  • The default case can now be removed from any switch statements on the union tag.
  1.       if err == nil {
  2.           return lib.JsonValueWithIntValue(int32(n))
  3.       }
  4.       return lib.JsonValueWithStringValue(s)
  5.   }
  7.   func reader(value lib.JsonValue) string {
  8.       switch value.Which() {
  9.       case lib.JsonValueIntValue:
  10.           return fmt.Sprintf("%d", value.IntValue)
  11.       case lib.JsonValueStringValue:
  12.           return value.StringValue
  13. -     case lib.JsonValue_unknownData:
  14. +     default:
  15.           return fmt.Sprintf("<%d unknown bytes>", len(value.GetUnknownData().Bytes))
  16. -     default:
  17. -         return "<unknown new member>"
  18.       }
  19.   }

HLCPP {#hlcpp-3}

  • The default case can now be removed from any switch statements on the union tag.
  1.     switch (value.Which()) {
  2.       case fidl_test::JsonValue::Tag::kIntValue:
  3.         return std::to_string(value.int_value());
  4.       case fidl_test::JsonValue::Tag::kStringValue:
  5.         return value.string_value();
  6.       case fidl_test::JsonValue::Tag::Invalid:
  7.         return "<uninitialized>";
  8.       case fidl_test::JsonValue::Tag::kUnknown: {
  9.         std::ostringstream out;
  10.         out << "<" << value.UnknownBytes()->size() << " unknown bytes>";
  11.         return out.str();
  12.       }
  13. -     default:
  14. -       return "<unknown new member>";
  15.     }
  16.   }

LLCPP {#llcpp-3}

  • The default case can now be removed from any switch statements on the union tag.
  1.     }
  2.     return fidl_test::JsonValue::WithStringValue(
  3.         std::make_unique<fidl::StringView>(fidl::heap_copy_str(s)));
  4.   }
  6.   std::string reader(const fidl_test::JsonValue& value) {
  7.     switch (value.which()) {
  8.       case fidl_test::JsonValue::Tag::kIntValue:
  9.         return std::to_string(value.int_value());
  10.       case fidl_test::JsonValue::Tag::kStringValue:
  11.         return std::string(value.string_value().data(), value.string_value().size());
  12.       case fidl_test::JsonValue::Tag::kUnknown:
  13. -     default:
  14.         return "<unknown>";
  15.     }
  16.   }

Rust {#rust-3}

  • The catch-all case can now be removed from any match statements on the union.
  1.   fn writer(s: &str) -> fidl_lib::JsonValue {
  2.       let as_int = s.parse::<i32>();
  3.       as_int
  4.           .map(|n| fidl_lib::JsonValue::IntValue(n))
  5.           .unwrap_or(fidl_lib::JsonValue::StringValue(s.to_string()))
  6.   }
  8.   fn reader(value: fidl_lib::JsonValue) -> String {
  9.       match value {
  10.           fidl_lib::JsonValue::IntValue(n) => format!("{}", n),
  11.           fidl_lib::JsonValue::StringValue(s) => s,
  12. -         _ => "<unknown>".to_string(),
  13. +         fidl_lib::JsonValueUnknown!() => "<unknown>".to_string(),
  14.       }
  15.   }