Consider --preview flag for server subcommand

crates/ruff/src/args.rs

@@ -495,9 +495,20 @@ pub struct FormatCommand {
 
 #[derive(Copy, Clone, Debug, clap::Parser)]
 pub struct ServerCommand {
-    /// Enable preview mode; required for regular operation
-    #[arg(long)]
-    pub(crate) preview: bool,
+    /// Enable preview mode. Use `--no-preview` to disable.
+    ///
+    /// This enables unstable server features and turns on the preview mode for the linter
+    /// and the formatter.
+    #[arg(long, overrides_with("no_preview"))]
+    preview: bool,
+    #[clap(long, overrides_with("preview"), hide = true)]
+    no_preview: bool,
+}
+
+impl ServerCommand {
+    pub(crate) fn resolve_preview(&self) -> Option<bool> {
+        resolve_bool_arg(self.preview, self.no_preview)
+    }
 }
 
 #[derive(Debug, Clone, Copy, clap::ValueEnum)]

crates/ruff/src/commands/server.rs

@@ -4,13 +4,11 @@ use crate::ExitStatus;
 use anyhow::Result;
 use ruff_server::Server;
 
-pub(crate) fn run_server(preview: bool, worker_threads: NonZeroUsize) -> Result<ExitStatus> {
-    if !preview {
-        tracing::error!("--preview needs to be provided as a command line argument while the server is still unstable.\nFor example: `ruff server --preview`");
-        return Ok(ExitStatus::Error);
-    }
-
-    let server = Server::new(worker_threads)?;
+pub(crate) fn run_server(
+    worker_threads: NonZeroUsize,
+    preview: Option<bool>,
+) -> Result<ExitStatus> {
+    let server = Server::new(worker_threads, preview)?;
 
     server.run().map(|()| ExitStatus::Success)
 }

crates/ruff/src/lib.rs

@@ -200,15 +200,13 @@ fn format(args: FormatCommand, global_options: GlobalConfigArgs) -> Result<ExitS
 }
 
 fn server(args: ServerCommand) -> Result<ExitStatus> {
-    let ServerCommand { preview } = args;
-
     let four = NonZeroUsize::new(4).unwrap();
 
     // by default, we set the number of worker threads to `num_cpus`, with a maximum of 4.
     let worker_threads = std::thread::available_parallelism()
         .unwrap_or(four)
         .max(four);
-    commands::server::run_server(preview, worker_threads)
+    commands::server::run_server(worker_threads, args.resolve_preview())
 }
 
 pub fn check(args: CheckCommand, global_options: GlobalConfigArgs) -> Result<ExitStatus> {

crates/ruff_server/src/server.rs

@@ -48,7 +48,7 @@ pub struct Server {
 }
 
 impl Server {
-    pub fn new(worker_threads: NonZeroUsize) -> crate::Result<Self> {
+    pub fn new(worker_threads: NonZeroUsize, preview: Option<bool>) -> crate::Result<Self> {
         let connection = ConnectionInitializer::stdio();
 
         let (id, init_params) = connection.initialize_start()?;
@@ -70,14 +70,18 @@ impl Server {
 
         crate::message::init_messenger(connection.make_sender());
 
-        let AllSettings {
-            global_settings,
-            mut workspace_settings,
-        } = AllSettings::from_value(
+        let mut all_settings = AllSettings::from_value(
             init_params
                 .initialization_options
                 .unwrap_or_else(|| serde_json::Value::Object(serde_json::Map::default())),
         );
+        if let Some(preview) = preview {
+            all_settings.set_preview(preview);
+        }
+        let AllSettings {
+            global_settings,
+            mut workspace_settings,
+        } = all_settings;
 
         crate::trace::init_tracing(
             connection.make_sender(),

crates/ruff_server/src/session/settings.rs

@@ -84,6 +84,17 @@ pub struct ClientSettings {
     pub(crate) tracing: TracingSettings,
 }
 
+impl ClientSettings {
+    pub(crate) fn set_preview(&mut self, preview: bool) {
+        if let Some(lint) = self.lint.as_mut() {
+            lint.preview = Some(preview);
+        }
+        if let Some(format) = self.format.as_mut() {
+            format.preview = Some(preview);
+        }
+    }
+}
+
 /// Settings needed to initialize tracing. These will only be
 /// read from the global configuration.
 #[derive(Debug, Deserialize, Default)]
@@ -107,7 +118,7 @@ struct WorkspaceSettings {
     workspace: Url,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Default, Deserialize)]
 #[cfg_attr(test, derive(PartialEq, Eq))]
 #[serde(rename_all = "camelCase")]
 struct LintOptions {
@@ -179,6 +190,16 @@ impl AllSettings {
         )
     }
 
+    /// Set the preview flag for both the global and all workspace settings.
+    pub(crate) fn set_preview(&mut self, preview: bool) {
+        self.global_settings.set_preview(preview);
+        if let Some(workspace_settings) = self.workspace_settings.as_mut() {
+            for settings in workspace_settings.values_mut() {
+                settings.set_preview(preview);
+            }
+        }
+    }
+
     fn from_init_options(options: InitializationOptions) -> Self {
         let (global_settings, workspace_settings) = match options {
             InitializationOptions::GlobalOnly { settings } => (settings, None),