Implement feature flag to gate rollout of flow modern syntax

Reviewed By: marcoww6

Differential Revision: D106303680

fbshipit-source-id: 593f5cff104e2abfa87f3a5b8adda92cb96848bd

Author: SamChou19815

compiler/crates/common/src/feature_flags.rs

@@ -208,6 +208,12 @@ pub struct FeatureFlags {
     #[serde(default)]
     pub enforce_module_name_prefix_for_non_haste: bool,
 
+    /// Use modern Flow syntax for generated object types.
+    /// This enables gradual rollout of exact object type syntax and readonly
+    /// properties across files.
+    #[serde(default)]
+    pub flow_modern_syntax: FeatureFlag,
+
     /// When enabled, the `@nogrep` annotation is included in the docblock
     /// header of generated artifacts. This annotation was historically always
     /// emitted but is no longer needed. This flag allows incremental removal
@@ -254,6 +260,7 @@ impl Default for FeatureFlags {
             enable_shadow_resolvers: Default::default(),
             allow_legacy_relay_resolver_tag: Default::default(),
             enforce_module_name_prefix_for_non_haste: Default::default(),
+            flow_modern_syntax: Default::default(),
             emit_nogrep_annotation: Default::default(),
             disable_more_precise_abstract_selection_raw_response_type: Default::default(),
 

compiler/crates/relay-compiler/relay-compiler-config-schema.json

@@ -706,6 +706,13 @@
           "type": "boolean",
           "default": false
         },
+        "flow_modern_syntax": {
+          "description": "Use modern Flow syntax for generated object types.\nThis enables gradual rollout of exact object type syntax and readonly\nproperties across files.",
+          "$ref": "#/$defs/FeatureFlag",
+          "default": {
+            "kind": "disabled"
+          }
+        },
         "legacy_include_path_in_required_reader_nodes": {
           "description": "The `path` field in `@required` Reader AST nodes is no longer used. But\nremoving them in one diff is too large of a change to ship at once.\n\nThis flag will allow us to use the rollout FeatureFlag to remove them\nacross a number of diffs.",
           "$ref": "#/$defs/FeatureFlag",
@@ -739,6 +746,13 @@
             "kind": "disabled"
           }
         },
+        "shard_extra_artifacts": {
+          "description": "Shard generated extra artifacts into subdirectories under\n`extraArtifactsOutput` that mirror the source file's relative path,\nhonoring `shardOutput` / `shardStripRegex`.",
+          "$ref": "#/$defs/FeatureFlag",
+          "default": {
+            "kind": "disabled"
+          }
+        },
         "skip_printing_nulls": {
           "$ref": "#/$defs/FeatureFlag",
           "default": {
@@ -968,6 +982,9 @@
               "kind": "enabled"
             },
             "enforce_module_name_prefix_for_non_haste": false,
+            "flow_modern_syntax": {
+              "kind": "disabled"
+            },
             "legacy_include_path_in_required_reader_nodes": {
               "kind": "disabled"
             },
@@ -981,6 +998,9 @@
             "relay_resolver_enable_interface_output_type": {
               "kind": "disabled"
             },
+            "shard_extra_artifacts": {
+              "kind": "disabled"
+            },
             "skip_printing_nulls": {
               "kind": "disabled"
             },

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

@@ -20,6 +20,7 @@ use crate::writer::Writer;
 pub struct FlowPrinter {
     result: String,
     indentation: usize,
+    use_flow_modern_syntax: bool,
 }
 
 impl Write for FlowPrinter {
@@ -152,10 +153,11 @@ impl Writer for FlowPrinter {
 }
 
 impl FlowPrinter {
-    pub fn new() -> Self {
+    pub fn new(use_flow_modern_syntax: bool) -> Self {
         Self {
             result: String::new(),
             indentation: 0,
+            use_flow_modern_syntax,
         }
     }
 
@@ -226,11 +228,15 @@ impl FlowPrinter {
 
     fn write_object(&mut self, props: &[Prop], exact: bool) -> FmtResult {
         if props.is_empty() && exact {
-            write!(&mut self.result, "{{||}}")?;
+            if self.use_flow_modern_syntax {
+                write!(&mut self.result, "{{}}")?;
+            } else {
+                write!(&mut self.result, "{{||}}")?;
+            }
             return Ok(());
         }
 
-        if exact {
+        if exact && !self.use_flow_modern_syntax {
             writeln!(&mut self.result, "{{|")?;
         } else {
             writeln!(&mut self.result, "{{")?;
@@ -259,7 +265,9 @@ impl FlowPrinter {
                         )?;
                         self.write_indentation()?;
                     }
-                    if key_value_pair.read_only {
+                    if key_value_pair.read_only && self.use_flow_modern_syntax {
+                        write!(&mut self.result, "readonly ")?;
+                    } else if key_value_pair.read_only {
                         write!(&mut self.result, "+")?;
                     }
                     write!(&mut self.result, "{}", key_value_pair.key)?;
@@ -294,7 +302,7 @@ impl FlowPrinter {
         }
         self.indentation -= 1;
         self.write_indentation()?;
-        if exact {
+        if exact && !self.use_flow_modern_syntax {
             write!(&mut self.result, "|}}")?;
         } else {
             write!(&mut self.result, "}}")?;
@@ -386,7 +394,11 @@ mod tests {
     use crate::writer::SortedASTList;
 
     fn print_type(ast: &AST) -> String {
-        let mut printer = Box::new(FlowPrinter::new());
+        print_type_with_flow_modern_syntax(ast, false)
+    }
+
+    fn print_type_with_flow_modern_syntax(ast: &AST, use_flow_modern_syntax: bool) -> String {
+        let mut printer = Box::new(FlowPrinter::new(use_flow_modern_syntax));
         printer.write(ast).unwrap();
         printer.into_string()
     }
@@ -517,6 +529,58 @@ mod tests {
         );
     }
 
+    #[test]
+    fn flow_modern_exact_object() {
+        assert_eq!(
+            print_type_with_flow_modern_syntax(
+                &AST::ExactObject(ExactObject::new(Vec::new())),
+                true,
+            ),
+            r"{}".to_string()
+        );
+
+        assert_eq!(
+            print_type_with_flow_modern_syntax(
+                &AST::ExactObject(ExactObject::new(vec![
+                    Prop::KeyValuePair(KeyValuePairProp {
+                        key: intern!("foo"),
+                        optional: true,
+                        read_only: false,
+                        value: AST::ExactObject(ExactObject::new(vec![
+                            Prop::KeyValuePair(KeyValuePairProp {
+                                key: intern!("nested_foo"),
+                                optional: true,
+                                read_only: false,
+                                value: AST::String,
+                            }),
+                            Prop::KeyValuePair(KeyValuePairProp {
+                                key: intern!("nested_foo2"),
+                                optional: false,
+                                read_only: true,
+                                value: AST::Number,
+                            }),
+                        ],)),
+                    }),
+                    Prop::KeyValuePair(KeyValuePairProp {
+                        key: intern!("bar"),
+                        optional: false,
+                        read_only: true,
+                        value: AST::Number,
+                    }),
+                ],)),
+                true,
+            ),
+            r"{
+  readonly bar: number,
+  foo?: {
+    nested_foo?: string,
+    readonly nested_foo2: number,
+  },
+}"
+            .to_string()
+        );
+    }
+
     #[test]
     fn inexact_object() {
         assert_eq!(
@@ -567,6 +631,35 @@ mod tests {
         );
     }
 
+    #[test]
+    fn flow_modern_inexact_object_preserves_spread() {
+        assert_eq!(
+            print_type_with_flow_modern_syntax(
+                &AST::InexactObject(InexactObject::new(vec![
+                    Prop::KeyValuePair(KeyValuePairProp {
+                        key: intern!("foo"),
+                        optional: false,
+                        read_only: false,
+                        value: AST::String,
+                    }),
+                    Prop::KeyValuePair(KeyValuePairProp {
+                        key: intern!("bar"),
+                        optional: true,
+                        read_only: true,
+                        value: AST::Number,
+                    })
+                ])),
+                true,
+            ),
+            r"{
+  readonly bar?: number,
+  foo: string,
+  ...
+}"
+            .to_string()
+        );
+    }
+
     #[test]
     fn one_of_input_object() {
         assert_eq!(
@@ -632,7 +725,7 @@ mod tests {
 
     #[test]
     fn import_type() {
-        let mut printer = Box::new(FlowPrinter::new());
+        let mut printer = Box::new(FlowPrinter::new(false));
         printer.write_import_type(&["A", "B"], "module").unwrap();
         assert_eq!(
             printer.into_string(),
@@ -642,7 +735,7 @@ mod tests {
 
     #[test]
     fn import_module() {
-        let mut printer = Box::new(FlowPrinter::new());
+        let mut printer = Box::new(FlowPrinter::new(false));
         printer.write_import_module_default("A", "module").unwrap();
         assert_eq!(printer.into_string(), "import A from \"module\";\n");
     }

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

@@ -158,7 +158,10 @@ fn generate_fragment_type_exports_section_impl(
             is_extra_artifact_branch_module,
         },
     );
-    let mut writer = new_writer_from_config(&project_config.typegen_config);
+    let mut writer = new_writer_from_config(
+        &project_config.typegen_config,
+        use_flow_modern_syntax(project_config, fragment_definition.name.item.0),
+    );
     write_fragment_type_exports_section(&typegen_context, fragment_definition, &mut writer)
         .unwrap();
     writer.into_string()
@@ -184,7 +187,10 @@ pub fn generate_named_validator_export(
             is_extra_artifact_branch_module: false,
         },
     );
-    let mut writer = new_writer_from_config(&project_config.typegen_config);
+    let mut writer = new_writer_from_config(
+        &project_config.typegen_config,
+        use_flow_modern_syntax(project_config, fragment_definition.name.item.0),
+    );
     write_validator_function(&typegen_context, fragment_definition, &mut writer).unwrap();
     let validator_function_body = writer.into_string();
 
@@ -220,7 +226,10 @@ pub fn generate_operation_type_exports_section(
             is_extra_artifact_branch_module: false,
         },
     );
-    let mut writer = new_writer_from_config(&project_config.typegen_config);
+    let mut writer = new_writer_from_config(
+        &project_config.typegen_config,
+        use_flow_modern_syntax(project_config, typegen_operation.name.item.0),
+    );
     write_operation_type_exports_section(
         &typegen_context,
         typegen_operation,
@@ -257,7 +266,10 @@ pub fn generate_split_operation_type_exports_section(
             is_extra_artifact_branch_module: false,
         },
     );
-    let mut writer = new_writer_from_config(&project_config.typegen_config);
+    let mut writer = new_writer_from_config(
+        &project_config.typegen_config,
+        use_flow_modern_syntax(project_config, typegen_operation.name.item.0),
+    );
 
     write_split_operation_type_exports_section(
         &typegen_context,
@@ -269,6 +281,13 @@ pub fn generate_split_operation_type_exports_section(
     writer.into_string()
 }
 
+fn use_flow_modern_syntax(project_config: &ProjectConfig, artifact_name: StringKey) -> bool {
+    project_config
+        .feature_flags
+        .flow_modern_syntax
+        .is_enabled_for(artifact_name)
+}
+
 /// An immutable grab bag of configuration, etc. for type generation.
 /// A new `TypegenContext` is created for each operation, fragment, and so on.
 struct TypegenContext<'a> {

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

@@ -388,10 +388,13 @@ pub trait Writer: Write {
     fn write_any_type_definition(&mut self, name: &str) -> FmtResult;
 }
 
-pub(crate) fn new_writer_from_config(config: &TypegenConfig) -> Box<dyn Writer> {
+pub(crate) fn new_writer_from_config(
+    config: &TypegenConfig,
+    use_flow_modern_syntax: bool,
+) -> Box<dyn Writer> {
     match config.language {
         TypegenLanguage::JavaScript => Box::<JavaScriptPrinter>::default(),
-        TypegenLanguage::Flow => Box::new(FlowPrinter::new()),
+        TypegenLanguage::Flow => Box::new(FlowPrinter::new(use_flow_modern_syntax)),
         TypegenLanguage::TypeScript => Box::new(TypeScriptPrinter::new(config)),
     }
 }

compiler/crates/relay-typegen/tests/generate_flow.rs

@@ -69,6 +69,14 @@ pub async fn transform_fixture(fixture: &Fixture<'_>) -> Result<String, String>
             .collect(),
         },
         relay_resolver_enable_interface_output_type: FeatureFlag::Enabled,
+        flow_modern_syntax: if fixture
+            .content
+            .contains("# feature_flags.flow_modern_syntax = false")
+        {
+            FeatureFlag::Disabled
+        } else {
+            FeatureFlag::Enabled
+        },
         ..Default::default()
     };
     let ir = build_ir_in_relay_mode(&schema, &ast.definitions, &feature_flags)