[rust] Better support for abstract types (unions and interfaces)

compiler/crates/relay-typegen/src/config.rs

@@ -22,7 +22,7 @@ impl Default for TypegenLanguage {
     }
 }
 
-#[derive(Debug, Deserialize, Default)]
+#[derive(Debug, Deserialize)]
 #[serde(deny_unknown_fields, rename_all = "camelCase")]
 pub struct TypegenConfig {
     /// The desired output language, "flow" or "typescript".
@@ -49,6 +49,14 @@ pub struct TypegenConfig {
     #[serde(default)]
     pub use_import_type_syntax: bool,
 
+    /// Whether to future proof enums by including "%future added value" as a possible value.
+    #[serde(default = "default_future_proofness")]
+    pub future_proof_enums: bool,
+
+    /// Whether to future proof union and interface types by including "%other" as a possible type.
+    #[serde(default = "default_future_proofness")]
+    pub future_proof_abstract_types: bool,
+
     /// A map from GraphQL scalar types to a custom JS type, example:
     /// { "Url": "String" }
     #[serde(default)]
@@ -59,3 +67,23 @@ pub struct TypegenConfig {
     #[serde(default)]
     pub haste: bool,
 }
+
+// Custom impl for Default to set future proofness to true when using Default::default().
+impl Default for TypegenConfig {
+    fn default() -> Self {
+        Self {
+            language: TypegenLanguage::default(),
+            enum_module_suffix: None,
+            optional_input_fields: vec![],
+            use_import_type_syntax: false,
+            future_proof_abstract_types: default_future_proofness(),
+            future_proof_enums: default_future_proofness(),
+            custom_scalar_types: FnvHashMap::default(),
+            haste: false,
+        }
+    }
+}
+
+fn default_future_proofness() -> bool {
+    true
+}

compiler/crates/relay-typegen/src/flow.rs

@@ -14,6 +14,20 @@ pub struct FlowPrinter {
 }
 
 impl Writer for FlowPrinter {
+    fn write_ast(&mut self, ast: &AST) -> String {
+        let mut writer = String::new();
+        self.write(&mut writer, ast)
+            .expect("Expected Ok result from writing Flow code");
+
+        writer
+    }
+}
+
+impl FlowPrinter {
+    pub fn new() -> Self {
+        Self { indentation: 0 }
+    }
+
     fn write(&mut self, writer: &mut dyn Write, ast: &AST) -> Result {
         match ast {
             AST::Any => write!(writer, "any"),
@@ -61,12 +75,6 @@ impl Writer for FlowPrinter {
             ),
         }
     }
-}
-
-impl FlowPrinter {
-    pub fn new() -> Self {
-        Self { indentation: 0 }
-    }
 
     fn write_indentation(&mut self, writer: &mut dyn Write) -> Result {
         writer.write_str(&"  ".repeat(self.indentation))
@@ -160,7 +168,7 @@ impl FlowPrinter {
                 writeln!(writer, ",")?;
                 continue;
             }
-            if let AST::OtherTypename = prop.value {
+            if prop.value.contains_other_typename() {
                 writeln!(writer, "// This will never be '%other', but we need some")?;
                 self.write_indentation(writer)?;
                 writeln!(
@@ -214,10 +222,10 @@ impl FlowPrinter {
     fn write_import_type(
         &mut self,
         writer: &mut dyn Write,
-        types: &Vec<StringKey>,
+        types: &[StringKey],
         from: &StringKey,
     ) -> Result {
-        writeln!(
+        write!(
             writer,
             "import type {{ {} }} from \"{}\";",
             types
@@ -235,7 +243,7 @@ impl FlowPrinter {
         alias: &StringKey,
         value: &StringKey,
     ) -> Result {
-        writeln!(writer, "declare export opaque type {}: {};", alias, value)
+        write!(writer, "declare export opaque type {}: {};", alias, value)
     }
 
     fn write_export_type_equals(
@@ -244,9 +252,7 @@ impl FlowPrinter {
         name: &StringKey,
         value: &AST,
     ) -> Result {
-        write!(writer, "export type {} = ", name)?;
-        self.write(writer, value)?;
-        writeln!(writer, ";")
+        write!(writer, "export type {} = {};", name, self.write_ast(value))
     }
 
     fn write_type_definition(
@@ -255,13 +261,11 @@ impl FlowPrinter {
         name: &StringKey,
         value: &AST,
     ) -> Result {
-        write!(writer, "type {} = ", name)?;
-        self.write(writer, value)?;
-        writeln!(writer, ";")
+        write!(writer, "type {} = {};", name, self.write_ast(value))
     }
 
-    fn write_export_list(&mut self, writer: &mut dyn Write, names: &Vec<StringKey>) -> Result {
-        writeln!(
+    fn write_export_list(&mut self, writer: &mut dyn Write, names: &[StringKey]) -> Result {
+        write!(
             writer,
             "export type {{ {} }};",
             names