Remove union member

Overview

Initial State

FIDL

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

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::JsonValue writer(const std::string& s) {
  std::optional<float> maybe_float = parse_as_float(s);
  ;
  if (maybe_float) {
    return fidl_test::JsonValue::WithIntValue(std::make_unique<int32_t>(*maybe_float));
  }
  std::optional<int32_t> maybe_int = parse_as_int(s);
  if (maybe_int) {
    return fidl_test::JsonValue::WithIntValue(std::make_unique<int32_t>(*maybe_int));
  }
  return fidl_test::JsonValue::WithStringValue(
      std::make_unique<fidl::StringView>(fidl::heap_copy_str(s)));
}

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 std::string(value.string_value().data(), value.string_value().size());
    case fidl_test::JsonValue::Tag::kFloatValue:
      return std::to_string(value.float_value());
    case fidl_test::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::JsonValue writer(const std::string& s) {
-   std::optional<float> maybe_float = parse_as_float(s);
-   ;
-   if (maybe_float) {
-     return fidl_test::JsonValue::WithIntValue(std::make_unique<int32_t>(*maybe_float));
-   }
    std::optional<int32_t> maybe_int = parse_as_int(s);
    if (maybe_int) {
      return fidl_test::JsonValue::WithIntValue(std::make_unique<int32_t>(*maybe_int));
    }
    return fidl_test::JsonValue::WithStringValue(
        std::make_unique<fidl::StringView>(fidl::heap_copy_str(s)));
  }
  
  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 std::string(value.string_value().data(), value.string_value().size());
-     case fidl_test::JsonValue::Tag::kFloatValue:
-       return std::to_string(value.float_value());
      case fidl_test::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 old variant

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

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::JsonValue::WithStringValue(
        std::make_unique<fidl::StringView>(fidl::heap_copy_str(s)));
  }
  
  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 std::string(value.string_value().data(), value.string_value().size());
      case fidl_test::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(),
      }
  }