Google is committed to advancing racial equity for Black communities. See how.

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

FIDL

type JsonValue = flexible union {
    1: int_value int32;
    2: string_value string:MAX;
    3: float_value float32;
};

Dart

fidllib.JsonValue writer(String s) {
  final asFloat = double.tryParse(s);
  if (asFloat != null) {
    return fidllib.JsonValue.withFloatValue(asFloat);
  }
  final asInt = int.tryParse(s);
  if (asInt != null) {
    return fidllib.JsonValue.withIntValue(asInt);
  }
  return fidllib.JsonValue.withStringValue(s);
}

String reader(fidllib.JsonValue value) {
  switch (value.$tag) {
    case fidllib.JsonValueTag.intValue:
      return '${value.intValue}';
    case fidllib.JsonValueTag.stringValue:
      return value.stringValue;
    case fidllib.JsonValueTag.floatValue:
      return '${value.floatValue}';
    default:
      return '<${value.$unknownData.data.length} unknown bytes>';
  }
}

Go

func writer(s string) lib.JsonValue {
    n, err := strconv.ParseInt(s, 10, 32)
    if err == nil {
        return lib.JsonValueWithIntValue(int32(n))
    }
    var f float64
    f, err = strconv.ParseFloat(s, 64)
    if err == nil {
        return lib.JsonValueWithFloatValue(float32(f))
    }
    return lib.JsonValueWithStringValue(s)
}

func reader(value lib.JsonValue) string {
    switch value.Which() {
    case lib.JsonValueIntValue:
        return fmt.Sprintf("%d", value.IntValue)
    case lib.JsonValueStringValue:
        return value.StringValue
    case lib.JsonValueFloatValue:
        return fmt.Sprintf("%f", value.FloatValue)
    default:
        return fmt.Sprintf("<%d unknown bytes>", len(value.GetUnknownData().Bytes))
    }
}

HLCPP

fidl_test::JsonValue writer(const std::string& s) {
  std::optional<float> maybe_float = parse_as_float(s);
  if (maybe_float) {
    return fidl_test::JsonValue::WithFloatValue(std::move(*maybe_float));
  }

  std::optional<int32_t> maybe_int = parse_as_int(s);
  if (maybe_int) {
    return fidl_test::JsonValue::WithIntValue(std::move(*maybe_int));
  }
  auto val = s;
  return fidl_test::JsonValue::WithStringValue(std::move(val));
}

std::string reader(const fidl_test::JsonValue& value) {
  switch (value.Which()) {
    case fidl_test::JsonValue::Tag::kIntValue:
      return std::to_string(value.int_value());
    case fidl_test::JsonValue::Tag::kStringValue:
      return value.string_value();
    case fidl_test::JsonValue::Tag::kFloatValue:
      return std::to_string(value.float_value());
    case fidl_test::JsonValue::Tag::Invalid:
      return "<uninitialized>";
    case fidl_test::JsonValue::Tag::kUnknown: {
      std::ostringstream out;
      out << "<" << value.UnknownBytes()->size() << " unknown bytes>";
      return out.str();
    }
  }
}

LLCPP

fidl_test::wire::JsonValue writer(fidl::AnyArena& allocator, const std::string& s) {
  std::optional<float> maybe_float = parse_as_float(s);
  if (maybe_float) {
    return fidl_test::wire::JsonValue::WithIntValue(allocator, *maybe_float);
  }
  std::optional<int32_t> maybe_int = parse_as_int(s);
  if (maybe_int) {
    return fidl_test::wire::JsonValue::WithIntValue(allocator, *maybe_int);
  }
  return fidl_test::wire::JsonValue::WithStringValue(allocator, allocator, s);
}

std::string reader(const fidl_test::wire::JsonValue& value) {
  switch (value.which()) {
    case fidl_test::wire::JsonValue::Tag::kIntValue:
      return std::to_string(value.int_value());
    case fidl_test::wire::JsonValue::Tag::kStringValue:
      return std::string(value.string_value().data(), value.string_value().size());
    case fidl_test::wire::JsonValue::Tag::kFloatValue:
      return std::to_string(value.float_value());
    case fidl_test::wire::JsonValue::Tag::kUnknown:
      return "<unknown>";
  }
}

Rust

fn writer(s: &str) -> fidl_lib::JsonValue {
    let as_float = s.parse::<f32>();
    if let Ok(val) = as_float {
        return fidl_lib::JsonValue::FloatValue(val);
    }
    let as_int = s.parse::<i32>();
    as_int
        .map(|n| fidl_lib::JsonValue::IntValue(n))
        .unwrap_or(fidl_lib::JsonValue::StringValue(s.to_string()))
}

fn reader(value: fidl_lib::JsonValue) -> String {
    match value {
        fidl_lib::JsonValue::IntValue(n) => format!("{}", n),
        fidl_lib::JsonValue::StringValue(s) => s,
        fidl_lib::JsonValue::FloatValue(v) => format!("{:.2}", v),
        fidl_lib::JsonValueUnknown!() => "<unknown>".to_string(),
    }
}

Update Source Code

Dart

  • 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.
  fidllib.JsonValue writer(String s) {
-   final asFloat = double.tryParse(s);
-   if (asFloat != null) {
-     return fidllib.JsonValue.withFloatValue(asFloat);
-   }
    final asInt = int.tryParse(s);
    if (asInt != null) {
      return fidllib.JsonValue.withIntValue(asInt);
    }
    return fidllib.JsonValue.withStringValue(s);
  }
  
  String reader(fidllib.JsonValue value) {
    switch (value.$tag) {
      case fidllib.JsonValueTag.intValue:
        return '${value.intValue}';
      case fidllib.JsonValueTag.stringValue:
        return value.stringValue;
-     case fidllib.JsonValueTag.floatValue:
-       return '${value.floatValue}';
+     case fidllib.JsonValueTag.$unknown:
+       return '<${value.$unknownData.data.length} unknown bytes>';
      default:
-       return '<${value.$unknownData.data.length} unknown bytes>';
+       return '<unknown new member>';
    }
  }
  

Go

  • 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.
  func writer(s string) lib.JsonValue {
    n, err := strconv.ParseInt(s, 10, 32)
    if err == nil {
        return lib.JsonValueWithIntValue(int32(n))
-   }
-   var f float64
-   f, err = strconv.ParseFloat(s, 64)
-   if err == nil {
-       return lib.JsonValueWithFloatValue(float32(f))
    }
    return lib.JsonValueWithStringValue(s)
  }
  
  func reader(value lib.JsonValue) string {
    switch value.Which() {
    case lib.JsonValueIntValue:
        return fmt.Sprintf("%d", value.IntValue)
    case lib.JsonValueStringValue:
        return value.StringValue
-   case lib.JsonValueFloatValue:
-       return fmt.Sprintf("%f", value.FloatValue)
+   case lib.JsonValue_unknownData:
+       return fmt.Sprintf("<%d unknown bytes>", len(value.GetUnknownData().Bytes))
    default:
-       return fmt.Sprintf("<%d unknown bytes>", len(value.GetUnknownData().Bytes))
+       return "<unknown new member>"
    }
  }
  

HLCPP

  • 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.
  fidl_test::JsonValue writer(const std::string& s) {
-   std::optional<float> maybe_float = parse_as_float(s);
-   if (maybe_float) {
-     return fidl_test::JsonValue::WithFloatValue(std::move(*maybe_float));
-   }
- 
    std::optional<int32_t> maybe_int = parse_as_int(s);
    if (maybe_int) {
      return fidl_test::JsonValue::WithIntValue(std::move(*maybe_int));
    }
    auto val = s;
    return fidl_test::JsonValue::WithStringValue(std::move(val));
  }
  
  std::string reader(const fidl_test::JsonValue& value) {
    switch (value.Which()) {
      case fidl_test::JsonValue::Tag::kIntValue:
        return std::to_string(value.int_value());
      case fidl_test::JsonValue::Tag::kStringValue:
        return value.string_value();
-     case fidl_test::JsonValue::Tag::kFloatValue:
-       return std::to_string(value.float_value());
      case fidl_test::JsonValue::Tag::Invalid:
        return "<uninitialized>";
      case fidl_test::JsonValue::Tag::kUnknown: {
        std::ostringstream out;
        out << "<" << value.UnknownBytes()->size() << " unknown bytes>";
        return out.str();
      }
+     default:
+       return "<unknown new member>";
    }
  }

LLCPP

  • 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.
  fidl_test::wire::JsonValue writer(fidl::AnyArena& allocator, const std::string& s) {
-   std::optional<float> maybe_float = parse_as_float(s);
-   if (maybe_float) {
-     return fidl_test::wire::JsonValue::WithIntValue(allocator, *maybe_float);
-   }
    std::optional<int32_t> maybe_int = parse_as_int(s);
    if (maybe_int) {
      return fidl_test::wire::JsonValue::WithIntValue(allocator, *maybe_int);
    }
    return fidl_test::wire::JsonValue::WithStringValue(allocator, allocator, s);
  }
  
  std::string reader(const fidl_test::wire::JsonValue& value) {
    switch (value.which()) {
      case fidl_test::wire::JsonValue::Tag::kIntValue:
        return std::to_string(value.int_value());
      case fidl_test::wire::JsonValue::Tag::kStringValue:
        return std::string(value.string_value().data(), value.string_value().size());
-     case fidl_test::wire::JsonValue::Tag::kFloatValue:
-       return std::to_string(value.float_value());
      case fidl_test::wire::JsonValue::Tag::kUnknown:
+     default:
        return "<unknown>";
    }
  }

Rust

  • 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.
  fn writer(s: &str) -> fidl_lib::JsonValue {
-     let as_float = s.parse::<f32>();
-     if let Ok(val) = as_float {
-         return fidl_lib::JsonValue::FloatValue(val);
-     }
      let as_int = s.parse::<i32>();
      as_int
          .map(|n| fidl_lib::JsonValue::IntValue(n))
          .unwrap_or(fidl_lib::JsonValue::StringValue(s.to_string()))
  }
  
  fn reader(value: fidl_lib::JsonValue) -> String {
      match value {
          fidl_lib::JsonValue::IntValue(n) => format!("{}", n),
          fidl_lib::JsonValue::StringValue(s) => s,
-         fidl_lib::JsonValue::FloatValue(v) => format!("{:.2}", v),
-         fidl_lib::JsonValueUnknown!() => "<unknown>".to_string(),
+         _ => "<unknown>".to_string(),
      }
  }

Update FIDL Library

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

Update Source Code

Dart

  • The default case can now be removed from any switch statements on the union tag.
    if (asInt != null) {
      return fidllib.JsonValue.withIntValue(asInt);
    }
    return fidllib.JsonValue.withStringValue(s);
  }
  
  String reader(fidllib.JsonValue value) {
    switch (value.$tag) {
      case fidllib.JsonValueTag.intValue:
        return '${value.intValue}';
      case fidllib.JsonValueTag.stringValue:
        return value.stringValue;
-     case fidllib.JsonValueTag.$unknown:
+     default:
        return '<${value.$unknownData.data.length} unknown bytes>';
-     default:
-       return '<unknown new member>';
    }
  }
  

Go

  • The default case can now be removed from any switch statements on the union tag.
    if err == nil {
        return lib.JsonValueWithIntValue(int32(n))
    }
    return lib.JsonValueWithStringValue(s)
  }
  
  func reader(value lib.JsonValue) string {
    switch value.Which() {
    case lib.JsonValueIntValue:
        return fmt.Sprintf("%d", value.IntValue)
    case lib.JsonValueStringValue:
        return value.StringValue
-   case lib.JsonValue_unknownData:
+   default:
        return fmt.Sprintf("<%d unknown bytes>", len(value.GetUnknownData().Bytes))
-   default:
-       return "<unknown new member>"
    }
  }
  

HLCPP

  • The default case can now be removed from any switch statements on the union tag.
    switch (value.Which()) {
      case fidl_test::JsonValue::Tag::kIntValue:
        return std::to_string(value.int_value());
      case fidl_test::JsonValue::Tag::kStringValue:
        return value.string_value();
      case fidl_test::JsonValue::Tag::Invalid:
        return "<uninitialized>";
      case fidl_test::JsonValue::Tag::kUnknown: {
        std::ostringstream out;
        out << "<" << value.UnknownBytes()->size() << " unknown bytes>";
        return out.str();
      }
-     default:
-       return "<unknown new member>";
    }
  }

LLCPP

  • The default case can now be removed from any switch statements on the union tag.
      return fidl_test::wire::JsonValue::WithIntValue(allocator, *maybe_int);
    }
    return fidl_test::wire::JsonValue::WithStringValue(allocator, allocator, s);
  }
  
  std::string reader(const fidl_test::wire::JsonValue& value) {
    switch (value.which()) {
      case fidl_test::wire::JsonValue::Tag::kIntValue:
        return std::to_string(value.int_value());
      case fidl_test::wire::JsonValue::Tag::kStringValue:
        return std::string(value.string_value().data(), value.string_value().size());
      case fidl_test::wire::JsonValue::Tag::kUnknown:
-     default:
        return "<unknown>";
    }
  }

Rust

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