Add remote server cross compilation (#19136)

This will allow us to compile debug builds of the remote-server for a
different architecture than the one we are developing on.

This also adds a CI step for building our remote server with minimal
dependencies.

Release Notes:

- N/A

crates/gpui/src/platform/blade/blade_renderer.rs

@@ -455,7 +455,7 @@ impl BladeRenderer {
         }
     }
 
-    #[cfg_attr(target_os = "macos", allow(dead_code))]
+    #[cfg_attr(any(target_os = "macos", feature = "wayland"), allow(dead_code))]
     pub fn viewport_size(&self) -> gpu::Extent {
         self.surface_config.size
     }

crates/gpui/src/platform/linux.rs

@@ -1,14 +1,22 @@
 mod dispatcher;
 mod headless;
 mod platform;
+#[cfg(any(feature = "wayland", feature = "x11"))]
 mod text_system;
+#[cfg(feature = "wayland")]
 mod wayland;
+#[cfg(feature = "x11")]
 mod x11;
+
+#[cfg(any(feature = "wayland", feature = "x11"))]
 mod xdg_desktop_portal;
 
 pub(crate) use dispatcher::*;
 pub(crate) use headless::*;
 pub(crate) use platform::*;
+#[cfg(any(feature = "wayland", feature = "x11"))]
 pub(crate) use text_system::*;
+#[cfg(feature = "wayland")]
 pub(crate) use wayland::*;
+#[cfg(feature = "x11")]
 pub(crate) use x11::*;

crates/gpui/src/platform/linux/platform.rs

@@ -19,32 +19,26 @@ use std::{
 };
 
 use anyhow::anyhow;
-use ashpd::desktop::file_chooser::{OpenFileRequest, SaveFileRequest};
-use ashpd::desktop::open_uri::{OpenDirectoryRequest, OpenFileRequest as OpenUriRequest};
-use ashpd::{url, ActivationToken};
 use async_task::Runnable;
 use calloop::channel::Channel;
 use calloop::{EventLoop, LoopHandle, LoopSignal};
-use filedescriptor::FileDescriptor;
 use flume::{Receiver, Sender};
 use futures::channel::oneshot;
 use parking_lot::Mutex;
 use util::ResultExt;
-use wayland_client::Connection;
-use wayland_protocols::wp::cursor_shape::v1::client::wp_cursor_shape_device_v1::Shape;
+
+#[cfg(any(feature = "wayland", feature = "x11"))]
 use xkbcommon::xkb::{self, Keycode, Keysym, State};
 
-use crate::platform::linux::wayland::WaylandClient;
+use crate::platform::NoopTextSystem;
 use crate::{
-    px, Action, AnyWindowHandle, BackgroundExecutor, ClipboardItem, CosmicTextSystem, CursorStyle,
-    DisplayId, ForegroundExecutor, Keymap, Keystroke, LinuxDispatcher, Menu, MenuItem, Modifiers,
-    OwnedMenu, PathPromptOptions, Pixels, Platform, PlatformDisplay, PlatformInputHandler,
-    PlatformTextSystem, PlatformWindow, Point, PromptLevel, Result, SemanticVersion, SharedString,
-    Size, Task, WindowAppearance, WindowOptions, WindowParams,
+    px, Action, AnyWindowHandle, BackgroundExecutor, ClipboardItem, CursorStyle, DisplayId,
+    ForegroundExecutor, Keymap, Keystroke, LinuxDispatcher, Menu, MenuItem, Modifiers, OwnedMenu,
+    PathPromptOptions, Pixels, Platform, PlatformDisplay, PlatformInputHandler, PlatformTextSystem,
+    PlatformWindow, Point, PromptLevel, Result, SemanticVersion, SharedString, Size, Task,
+    WindowAppearance, WindowOptions, WindowParams,
 };
 
-use super::x11::X11Client;
-
 pub(crate) const SCROLL_LINES: f32 = 3.0;
 
 // Values match the defaults on GTK.
@@ -93,7 +87,7 @@ pub(crate) struct PlatformHandlers {
 pub(crate) struct LinuxCommon {
     pub(crate) background_executor: BackgroundExecutor,
     pub(crate) foreground_executor: ForegroundExecutor,
-    pub(crate) text_system: Arc<CosmicTextSystem>,
+    pub(crate) text_system: Arc<dyn PlatformTextSystem>,
     pub(crate) appearance: WindowAppearance,
     pub(crate) auto_hide_scrollbars: bool,
     pub(crate) callbacks: PlatformHandlers,
@@ -104,7 +98,12 @@ pub(crate) struct LinuxCommon {
 impl LinuxCommon {
     pub fn new(signal: LoopSignal) -> (Self, Channel<Runnable>) {
         let (main_sender, main_receiver) = calloop::channel::channel::<Runnable>();
-        let text_system = Arc::new(CosmicTextSystem::new());
+        #[cfg(any(feature = "wayland", feature = "x11"))]
+        let text_system = Arc::new(crate::CosmicTextSystem::new());
+
+        #[cfg(not(any(feature = "wayland", feature = "x11")))]
+        let text_system = Arc::new(crate::NoopTextSystem::new());
+
         let callbacks = PlatformHandlers::default();
 
         let dispatcher = Arc::new(LinuxDispatcher::new(main_sender.clone()));
@@ -264,6 +263,11 @@ impl<P: LinuxClient + 'static> Platform for P {
         options: PathPromptOptions,
     ) -> oneshot::Receiver<Result<Option<Vec<PathBuf>>>> {
         let (done_tx, done_rx) = oneshot::channel();
+
+        #[cfg(not(any(feature = "wayland", feature = "x11")))]
+        done_tx.send(Ok(None));
+
+        #[cfg(any(feature = "wayland", feature = "x11"))]
         self.foreground_executor()
             .spawn(async move {
                 let title = if options.directories {
@@ -272,7 +276,7 @@ impl<P: LinuxClient + 'static> Platform for P {
                     "Open File"
                 };
 
-                let request = match OpenFileRequest::default()
+                let request = match ashpd::desktop::file_chooser::OpenFileRequest::default()
                     .modal(true)
                     .title(title)
                     .multiple(options.multiple)
@@ -310,37 +314,47 @@ impl<P: LinuxClient + 'static> Platform for P {
 
     fn prompt_for_new_path(&self, directory: &Path) -> oneshot::Receiver<Result<Option<PathBuf>>> {
         let (done_tx, done_rx) = oneshot::channel();
-        let directory = directory.to_owned();
-        self.foreground_executor()
-            .spawn(async move {
-                let request = match SaveFileRequest::default()
-                    .modal(true)
-                    .title("Save File")
-                    .current_folder(directory)
-                    .expect("pathbuf should not be nul terminated")
-                    .send()
-                    .await
-                {
-                    Ok(request) => request,
-                    Err(err) => {
-                        let result = match err {
-                            ashpd::Error::PortalNotFound(_) => anyhow!(FILE_PICKER_PORTAL_MISSING),
-                            err => err.into(),
-                        };
-                        done_tx.send(Err(result));
-                        return;
-                    }
-                };
 
-                let result = match request.response() {
-                    Ok(response) => Ok(response
-                        .uris()
-                        .first()
-                        .and_then(|uri| uri.to_file_path().ok())),
-                    Err(ashpd::Error::Response(_)) => Ok(None),
-                    Err(e) => Err(e.into()),
-                };
-                done_tx.send(result);
+        #[cfg(not(any(feature = "wayland", feature = "x11")))]
+        done_tx.send(Ok(None));
+
+        #[cfg(any(feature = "wayland", feature = "x11"))]
+        self.foreground_executor()
+            .spawn({
+                let directory = directory.to_owned();
+
+                async move {
+                    let request = match ashpd::desktop::file_chooser::SaveFileRequest::default()
+                        .modal(true)
+                        .title("Save File")
+                        .current_folder(directory)
+                        .expect("pathbuf should not be nul terminated")
+                        .send()
+                        .await
+                    {
+                        Ok(request) => request,
+                        Err(err) => {
+                            let result = match err {
+                                ashpd::Error::PortalNotFound(_) => {
+                                    anyhow!(FILE_PICKER_PORTAL_MISSING)
+                                }
+                                err => err.into(),
+                            };
+                            done_tx.send(Err(result));
+                            return;
+                        }
+                    };
+
+                    let result = match request.response() {
+                        Ok(response) => Ok(response
+                            .uris()
+                            .first()
+                            .and_then(|uri| uri.to_file_path().ok())),
+                        Err(ashpd::Error::Response(_)) => Ok(None),
+                        Err(e) => Err(e.into()),
+                    };
+                    done_tx.send(result);
+                }
             })
             .detach();
 
@@ -518,16 +532,17 @@ impl<P: LinuxClient + 'static> Platform for P {
     fn add_recent_document(&self, _path: &Path) {}
 }
 
+#[cfg(any(feature = "wayland", feature = "x11"))]
 pub(super) fn open_uri_internal(
     executor: BackgroundExecutor,
     uri: &str,
     activation_token: Option<String>,
 ) {
-    if let Some(uri) = url::Url::parse(uri).log_err() {
+    if let Some(uri) = ashpd::url::Url::parse(uri).log_err() {
         executor
             .spawn(async move {
-                match OpenUriRequest::default()
-                    .activation_token(activation_token.clone().map(ActivationToken::from))
+                match ashpd::desktop::open_uri::OpenFileRequest::default()
+                    .activation_token(activation_token.clone().map(ashpd::ActivationToken::from))
                     .send_uri(&uri)
                     .await
                 {
@@ -551,6 +566,7 @@ pub(super) fn open_uri_internal(
     }
 }
 
+#[cfg(any(feature = "x11", feature = "wayland"))]
 pub(super) fn reveal_path_internal(
     executor: BackgroundExecutor,
     path: PathBuf,
@@ -559,8 +575,8 @@ pub(super) fn reveal_path_internal(
     executor
         .spawn(async move {
             if let Some(dir) = File::open(path.clone()).log_err() {
-                match OpenDirectoryRequest::default()
-                    .activation_token(activation_token.map(ActivationToken::from))
+                match ashpd::desktop::open_uri::OpenDirectoryRequest::default()
+                    .activation_token(activation_token.map(ashpd::ActivationToken::from))
                     .send(&dir.as_fd())
                     .await
                 {
@@ -582,6 +598,7 @@ pub(super) fn is_within_click_distance(a: Point<Pixels>, b: Point<Pixels>) -> bo
     diff.x.abs() <= DOUBLE_CLICK_DISTANCE && diff.y.abs() <= DOUBLE_CLICK_DISTANCE
 }
 
+#[cfg(any(feature = "wayland", feature = "x11"))]
 pub(super) fn get_xkb_compose_state(cx: &xkb::Context) -> Option<xkb::compose::State> {
     let mut locales = Vec::default();
     if let Some(locale) = std::env::var_os("LC_CTYPE") {
@@ -603,7 +620,8 @@ pub(super) fn get_xkb_compose_state(cx: &xkb::Context) -> Option<xkb::compose::S
     state
 }
 
-pub(super) unsafe fn read_fd(mut fd: FileDescriptor) -> Result<Vec<u8>> {
+#[cfg(any(feature = "wayland", feature = "x11"))]
+pub(super) unsafe fn read_fd(mut fd: filedescriptor::FileDescriptor) -> Result<Vec<u8>> {
     let mut file = File::from_raw_fd(fd.as_raw_fd());
     let mut buffer = Vec::new();
     file.read_to_end(&mut buffer)?;
@@ -611,32 +629,6 @@ pub(super) unsafe fn read_fd(mut fd: FileDescriptor) -> Result<Vec<u8>> {
 }
 
 impl CursorStyle {
-    pub(super) fn to_shape(&self) -> Shape {
-        match self {
-            CursorStyle::Arrow => Shape::Default,
-            CursorStyle::IBeam => Shape::Text,
-            CursorStyle::Crosshair => Shape::Crosshair,
-            CursorStyle::ClosedHand => Shape::Grabbing,
-            CursorStyle::OpenHand => Shape::Grab,
-            CursorStyle::PointingHand => Shape::Pointer,
-            CursorStyle::ResizeLeft => Shape::WResize,
-            CursorStyle::ResizeRight => Shape::EResize,
-            CursorStyle::ResizeLeftRight => Shape::EwResize,
-            CursorStyle::ResizeUp => Shape::NResize,
-            CursorStyle::ResizeDown => Shape::SResize,
-            CursorStyle::ResizeUpDown => Shape::NsResize,
-            CursorStyle::ResizeUpLeftDownRight => Shape::NwseResize,
-            CursorStyle::ResizeUpRightDownLeft => Shape::NeswResize,
-            CursorStyle::ResizeColumn => Shape::ColResize,
-            CursorStyle::ResizeRow => Shape::RowResize,
-            CursorStyle::IBeamCursorForVerticalLayout => Shape::VerticalText,
-            CursorStyle::OperationNotAllowed => Shape::NotAllowed,
-            CursorStyle::DragLink => Shape::Alias,
-            CursorStyle::DragCopy => Shape::Copy,
-            CursorStyle::ContextualMenu => Shape::ContextMenu,
-        }
-    }
-
     pub(super) fn to_icon_name(&self) -> String {
         // Based on cursor names from https://gitlab.gnome.org/GNOME/adwaita-icon-theme (GNOME)
         // and https://github.com/KDE/breeze (KDE). Both of them seem to be also derived from
@@ -668,6 +660,7 @@ impl CursorStyle {
     }
 }
 
+#[cfg(any(feature = "wayland", feature = "x11"))]
 impl Keystroke {
     pub(super) fn from_xkb(state: &State, modifiers: Modifiers, keycode: Keycode) -> Self {
         let mut modifiers = modifiers;
@@ -813,6 +806,7 @@ impl Keystroke {
     }
 }
 
+#[cfg(any(feature = "wayland", feature = "x11"))]
 impl Modifiers {
     pub(super) fn from_xkb(keymap_state: &State) -> Self {
         let shift = keymap_state.mod_name_is_active(xkb::MOD_NAME_SHIFT, xkb::STATE_MODS_EFFECTIVE);

crates/gpui/src/platform/linux/wayland.rs

@@ -6,3 +6,35 @@ mod serial;
 mod window;
 
 pub(crate) use client::*;
+
+use wayland_protocols::wp::cursor_shape::v1::client::wp_cursor_shape_device_v1::Shape;
+
+use crate::CursorStyle;
+
+impl CursorStyle {
+    pub(super) fn to_shape(&self) -> Shape {
+        match self {
+            CursorStyle::Arrow => Shape::Default,
+            CursorStyle::IBeam => Shape::Text,
+            CursorStyle::Crosshair => Shape::Crosshair,
+            CursorStyle::ClosedHand => Shape::Grabbing,
+            CursorStyle::OpenHand => Shape::Grab,
+            CursorStyle::PointingHand => Shape::Pointer,
+            CursorStyle::ResizeLeft => Shape::WResize,
+            CursorStyle::ResizeRight => Shape::EResize,
+            CursorStyle::ResizeLeftRight => Shape::EwResize,
+            CursorStyle::ResizeUp => Shape::NResize,
+            CursorStyle::ResizeDown => Shape::SResize,
+            CursorStyle::ResizeUpDown => Shape::NsResize,
+            CursorStyle::ResizeUpLeftDownRight => Shape::NwseResize,
+            CursorStyle::ResizeUpRightDownLeft => Shape::NeswResize,
+            CursorStyle::ResizeColumn => Shape::ColResize,
+            CursorStyle::ResizeRow => Shape::RowResize,
+            CursorStyle::IBeamCursorForVerticalLayout => Shape::VerticalText,
+            CursorStyle::OperationNotAllowed => Shape::NotAllowed,
+            CursorStyle::DragLink => Shape::Alias,
+            CursorStyle::DragCopy => Shape::Copy,
+            CursorStyle::ContextualMenu => Shape::ContextMenu,
+        }
+    }
+}

crates/gpui/src/platform/linux/x11/client.rs

@@ -1421,10 +1421,12 @@ impl LinuxClient for X11Client {
     }
 
     fn open_uri(&self, uri: &str) {
+        #[cfg(any(feature = "wayland", feature = "x11"))]
         open_uri_internal(self.background_executor(), uri, None);
     }
 
     fn reveal_path(&self, path: PathBuf) {
+        #[cfg(any(feature = "x11", feature = "wayland"))]
         reveal_path_internal(self.background_executor(), path, None);
     }
 

crates/gpui/src/platform/linux/xdg_desktop_portal.rs

@@ -11,7 +11,9 @@ use crate::{BackgroundExecutor, WindowAppearance};
 
 pub enum Event {
     WindowAppearance(WindowAppearance),
+    #[cfg_attr(feature = "x11", allow(dead_code))]
     CursorTheme(String),
+    #[cfg_attr(feature = "x11", allow(dead_code))]
     CursorSize(u32),
 }
 

crates/gpui/src/platform/mac.rs

@@ -17,9 +17,14 @@ use metal_renderer as renderer;
 use crate::platform::blade as renderer;
 
 mod attributed_string;
+
+#[cfg(feature = "font-kit")]
 mod open_type;
-mod platform;
+
+#[cfg(feature = "font-kit")]
 mod text_system;
+
+mod platform;
 mod window;
 mod window_appearance;
 
@@ -39,9 +44,11 @@ pub(crate) use dispatcher::*;
 pub(crate) use display::*;
 pub(crate) use display_link::*;
 pub(crate) use platform::*;
-pub(crate) use text_system::*;
 pub(crate) use window::*;
 
+#[cfg(feature = "font-kit")]
+pub(crate) use text_system::*;
+
 trait BoolExt {
     fn to_objc(self) -> BOOL;
 }

crates/gpui/src/platform/mac/platform.rs

@@ -6,9 +6,9 @@ use super::{
 use crate::{
     hash, Action, AnyWindowHandle, BackgroundExecutor, ClipboardEntry, ClipboardItem,
     ClipboardString, CursorStyle, ForegroundExecutor, Image, ImageFormat, Keymap, MacDispatcher,
-    MacDisplay, MacTextSystem, MacWindow, Menu, MenuItem, PathPromptOptions, Platform,
-    PlatformDisplay, PlatformTextSystem, PlatformWindow, Result, SemanticVersion, Task,
-    WindowAppearance, WindowParams,
+    MacDisplay, MacWindow, Menu, MenuItem, PathPromptOptions, Platform, PlatformDisplay,
+    PlatformTextSystem, PlatformWindow, Result, SemanticVersion, Task, WindowAppearance,
+    WindowParams,
 };
 use anyhow::anyhow;
 use block::ConcreteBlock;
@@ -145,7 +145,7 @@ pub(crate) struct MacPlatform(Mutex<MacPlatformState>);
 pub(crate) struct MacPlatformState {
     background_executor: BackgroundExecutor,
     foreground_executor: ForegroundExecutor,
-    text_system: Arc<MacTextSystem>,
+    text_system: Arc<dyn PlatformTextSystem>,
     renderer_context: renderer::Context,
     headless: bool,
     pasteboard: id,
@@ -171,11 +171,18 @@ impl Default for MacPlatform {
 impl MacPlatform {
     pub(crate) fn new(headless: bool) -> Self {
         let dispatcher = Arc::new(MacDispatcher::new());
+
+        #[cfg(feature = "font-kit")]
+        let text_system = Arc::new(crate::MacTextSystem::new());
+
+        #[cfg(not(feature = "font-kit"))]
+        let text_system = Arc::new(crate::NoopTextSystem::new());
+
         Self(Mutex::new(MacPlatformState {
-            background_executor: BackgroundExecutor::new(dispatcher.clone()),
             headless,
+            text_system,
+            background_executor: BackgroundExecutor::new(dispatcher.clone()),
             foreground_executor: ForegroundExecutor::new(dispatcher),
-            text_system: Arc::new(MacTextSystem::new()),
             renderer_context: renderer::Context::default(),
             pasteboard: unsafe { NSPasteboard::generalPasteboard(nil) },
             text_hash_pasteboard_type: unsafe { ns_string("zed-text-hash") },