zed-industries/zed
1
1
Fork 0
mirror of https://github.com/zed-industries/zed.git synced 2024-11-07 20:39:04 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'main' into import-theme

Browse Source
This commit is contained in:
Nate Butler 2023-11-02 20:16:09 -04:00
commit b4e2368943
145 changed files with 9416 additions and 5309 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
Cargo.lock generated
View File

@ -1541,7 +1541,6 @@ dependencies = [
"schemars",
"serde",
"serde_derive",
"settings",
"settings2",
"smol",
"sum_tree",
@ -7796,7 +7795,6 @@ dependencies = [
"anyhow",
"collections",
"feature_flags2",
"fs",
"fs2",
"futures 0.3.28",
"gpui2",
@ -10813,6 +10811,44 @@ dependencies = [
"uuid 1.4.1",
]
[[package]]
name = "workspace2"
version = "0.1.0"
dependencies = [
"anyhow",
"async-recursion 1.0.5",
"bincode",
"call2",
"client2",
"collections",
"db2",
"env_logger 0.9.3",
"fs2",
"futures 0.3.28",
"gpui2",
"indoc",
"install_cli2",
"itertools 0.10.5",
"language2",
"lazy_static",
"log",
"node_runtime",
"parking_lot 0.11.2",
"postage",
"project2",
"schemars",
"serde",
"serde_derive",
"serde_json",
"settings2",
"smallvec",
"terminal2",
"theme2",
"ui2",
"util",
"uuid 1.4.1",
]
[[package]]
name = "ws2_32-sys"
version = "0.2.1"
@ -11128,6 +11164,7 @@ dependencies = [
"urlencoding",
"util",
"uuid 1.4.1",
"workspace2",
]
[[package]]

2
Cargo.toml
View File

@ -100,7 +100,7 @@ members = [
"crates/semantic_index",
"crates/vim",
"crates/vcs_menu",
"crates/workspace",
"crates/workspace2",
"crates/welcome",
"crates/xtask",
"crates/zed",

6
crates/ai2/Cargo.toml
View File

@ -12,9 +12,9 @@ doctest = false
test-support = []
[dependencies]
gpui2 = { path = "../gpui2" }
gpui = { package = "gpui2", path = "../gpui2" }
util = { path = "../util" }
language2 = { path = "../language2" }
language = { package = "language2", path = "../language2" }
async-trait.workspace = true
anyhow.workspace = true
futures.workspace = true
@ -35,4 +35,4 @@ rusqlite = { version = "0.29.0", features = ["blob", "array", "modern_sqlite"] }
bincode = "1.3.3"
[dev-dependencies]
gpui2 = { path = "../gpui2", features = ["test-support"] }
gpui = { package = "gpui2", path = "../gpui2", features = ["test-support"] }

2
crates/ai2/src/auth.rs
View File

@ -1,4 +1,4 @@
use gpui2::AppContext;
use gpui::AppContext;
#[derive(Clone, Debug)]
pub enum ProviderCredential {

2
crates/ai2/src/embedding.rs
View File

@ -81,7 +81,7 @@ mod tests {
use super::*;
use rand::prelude::*;
#[gpui2::test]
#[gpui::test]
fn test_similarity(mut rng: StdRng) {
assert_eq!(
Embedding::from(vec![1., 0., 0., 0., 0.])

2
crates/ai2/src/prompts/base.rs
View File

@ -2,7 +2,7 @@ use std::cmp::Reverse;
use std::ops::Range;
use std::sync::Arc;
use language2::BufferSnapshot;
use language::BufferSnapshot;
use util::ResultExt;
use crate::models::LanguageModel;

4
crates/ai2/src/prompts/file_context.rs
View File

@ -1,6 +1,6 @@
use anyhow::anyhow;
use language2::BufferSnapshot;
use language2::ToOffset;
use language::BufferSnapshot;
use language::ToOffset;
use crate::models::LanguageModel;
use crate::models::TruncationDirection;

4
crates/ai2/src/prompts/repository_context.rs
View File

@ -2,8 +2,8 @@ use crate::prompts::base::{PromptArguments, PromptTemplate};
use std::fmt::Write;
use std::{ops::Range, path::PathBuf};
use gpui2::{AsyncAppContext, Model};
use language2::{Anchor, Buffer};
use gpui::{AsyncAppContext, Model};
use language::{Anchor, Buffer};
#[derive(Clone)]
pub struct PromptCodeSnippet {

2
crates/ai2/src/providers/open_ai/completion.rs
View File

@ -3,7 +3,7 @@ use futures::{
future::BoxFuture, io::BufReader, stream::BoxStream, AsyncBufReadExt, AsyncReadExt, FutureExt,
Stream, StreamExt,
};
use gpui2::{AppContext, BackgroundExecutor};
use gpui::{AppContext, BackgroundExecutor};
use isahc::{http::StatusCode, Request, RequestExt};
use parking_lot::RwLock;
use serde::{Deserialize, Serialize};

4
crates/ai2/src/providers/open_ai/embedding.rs
View File

@ -1,8 +1,8 @@
use anyhow::{anyhow, Result};
use async_trait::async_trait;
use futures::AsyncReadExt;
use gpui2::BackgroundExecutor;
use gpui2::{serde_json, AppContext};
use gpui::BackgroundExecutor;
use gpui::{serde_json, AppContext};
use isahc::http::StatusCode;
use isahc::prelude::Configurable;
use isahc::{AsyncBody, Response};

2
crates/ai2/src/test.rs
View File

@ -5,7 +5,7 @@ use std::{
use async_trait::async_trait;
use futures::{channel::mpsc, future::BoxFuture, stream::BoxStream, FutureExt, StreamExt};
use gpui2::AppContext;
use gpui::AppContext;
use parking_lot::Mutex;
use crate::{

2
crates/audio2/Cargo.toml
View File

@ -9,7 +9,7 @@ path = "src/audio2.rs"
doctest = false
[dependencies]
gpui2 = { path = "../gpui2" }
gpui = { package = "gpui2", path = "../gpui2" }
collections = { path = "../collections" }
util = { path = "../util" }

2
crates/audio2/src/assets.rs
View File

@ -2,7 +2,7 @@ use std::{io::Cursor, sync::Arc};
use anyhow::Result;
use collections::HashMap;
use gpui2::{AppContext, AssetSource};
use gpui::{AppContext, AssetSource};
use rodio::{
source::{Buffered, SamplesConverter},
Decoder, Source,

2
crates/audio2/src/audio2.rs
View File

@ -1,5 +1,5 @@
use assets::SoundRegistry;
use gpui2::{AppContext, AssetSource};
use gpui::{AppContext, AssetSource};
use rodio::{OutputStream, OutputStreamHandle};
use util::ResultExt;

36
crates/call2/Cargo.toml
View File

@ -10,26 +10,26 @@ doctest = false
[features]
test-support = [
"client2/test-support",
"client/test-support",
"collections/test-support",
"gpui2/test-support",
"live_kit_client2/test-support",
"project2/test-support",
"gpui/test-support",
"live_kit_client/test-support",
"project/test-support",
"util/test-support"
]
[dependencies]
audio2 = { path = "../audio2" }
client2 = { path = "../client2" }
audio = { package = "audio2", path = "../audio2" }
client = { package = "client2", path = "../client2" }
collections = { path = "../collections" }
gpui2 = { path = "../gpui2" }
gpui = { package = "gpui2", path = "../gpui2" }
log.workspace = true
live_kit_client2 = { path = "../live_kit_client2" }
fs2 = { path = "../fs2" }
language2 = { path = "../language2" }
live_kit_client = { package = "live_kit_client2", path = "../live_kit_client2" }
fs = { package = "fs2", path = "../fs2" }
language = { package = "language2", path = "../language2" }
media = { path = "../media" }
project2 = { path = "../project2" }
settings2 = { path = "../settings2" }
project = { package = "project2", path = "../project2" }
settings = { package = "settings2", path = "../settings2" }
util = { path = "../util" }
anyhow.workspace = true
@ -42,11 +42,11 @@ serde_json.workspace = true
serde_derive.workspace = true
[dev-dependencies]
client2 = { path = "../client2", features = ["test-support"] }
fs2 = { path = "../fs2", features = ["test-support"] }
language2 = { path = "../language2", features = ["test-support"] }
client = { package = "client2", path = "../client2", features = ["test-support"] }
fs = { package = "fs2", path = "../fs2", features = ["test-support"] }
language = { package = "language2", path = "../language2", features = ["test-support"] }
collections = { path = "../collections", features = ["test-support"] }
gpui2 = { path = "../gpui2", features = ["test-support"] }
live_kit_client2 = { path = "../live_kit_client2", features = ["test-support"] }
project2 = { path = "../project2", features = ["test-support"] }
gpui = { package = "gpui2", path = "../gpui2", features = ["test-support"] }
live_kit_client = { package = "live_kit_client2", path = "../live_kit_client2", features = ["test-support"] }
project = { package = "project2", path = "../project2", features = ["test-support"] }
util = { path = "../util", features = ["test-support"] }

12
crates/call2/src/call2.rs
View File

@ -3,21 +3,21 @@ pub mod participant;
pub mod room;
use anyhow::{anyhow, Result};
use audio2::Audio;
use audio::Audio;
use call_settings::CallSettings;
use client2::{
use client::{
proto, ClickhouseEvent, Client, TelemetrySettings, TypedEnvelope, User, UserStore,
ZED_ALWAYS_ACTIVE,
};
use collections::HashSet;
use futures::{future::Shared, FutureExt};
use gpui2::{
use gpui::{
AppContext, AsyncAppContext, Context, EventEmitter, Model, ModelContext, Subscription, Task,
WeakModel,
};
use postage::watch;
use project2::Project;
use settings2::Settings;
use project::Project;
use settings::Settings;
use std::sync::Arc;
pub use participant::ParticipantLocation;
@ -50,7 +50,7 @@ pub struct ActiveCall {
),
client: Arc<Client>,
user_store: Model<UserStore>,
_subscriptions: Vec<client2::Subscription>,
_subscriptions: Vec<client::Subscription>,
}
impl EventEmitter for ActiveCall {

4
crates/call2/src/call_settings.rs
View File

@ -1,8 +1,8 @@
use anyhow::Result;
use gpui2::AppContext;
use gpui::AppContext;
use schemars::JsonSchema;
use serde_derive::{Deserialize, Serialize};
use settings2::Settings;
use settings::Settings;
#[derive(Deserialize, Debug)]
pub struct CallSettings {

16
crates/call2/src/participant.rs
View File

@ -1,11 +1,11 @@
use anyhow::{anyhow, Result};
use client2::ParticipantIndex;
use client2::{proto, User};
use client::ParticipantIndex;
use client::{proto, User};
use collections::HashMap;
use gpui2::WeakModel;
pub use live_kit_client2::Frame;
use live_kit_client2::{RemoteAudioTrack, RemoteVideoTrack};
use project2::Project;
use gpui::WeakModel;
pub use live_kit_client::Frame;
use live_kit_client::{RemoteAudioTrack, RemoteVideoTrack};
use project::Project;
use std::sync::Arc;
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
@ -47,6 +47,6 @@ pub struct RemoteParticipant {
pub participant_index: ParticipantIndex,
pub muted: bool,
pub speaking: bool,
pub video_tracks: HashMap<live_kit_client2::Sid, Arc<RemoteVideoTrack>>,
pub audio_tracks: HashMap<live_kit_client2::Sid, Arc<RemoteAudioTrack>>,
pub video_tracks: HashMap<live_kit_client::Sid, Arc<RemoteVideoTrack>>,
pub audio_tracks: HashMap<live_kit_client::Sid, Arc<RemoteAudioTrack>>,
}

32
crates/call2/src/room.rs
View File

@ -4,25 +4,25 @@ use crate::{
IncomingCall,
};
use anyhow::{anyhow, Result};
use audio2::{Audio, Sound};
use client2::{
use audio::{Audio, Sound};
use client::{
proto::{self, PeerId},
Client, ParticipantIndex, TypedEnvelope, User, UserStore,
};
use collections::{BTreeMap, HashMap, HashSet};
use fs2::Fs;
use fs::Fs;
use futures::{FutureExt, StreamExt};
use gpui2::{
use gpui::{
AppContext, AsyncAppContext, Context, EventEmitter, Model, ModelContext, Task, WeakModel,
};
use language2::LanguageRegistry;
use live_kit_client2::{
use language::LanguageRegistry;
use live_kit_client::{
LocalAudioTrack, LocalTrackPublication, LocalVideoTrack, RemoteAudioTrackUpdate,
RemoteVideoTrackUpdate,
};
use postage::{sink::Sink, stream::Stream, watch};
use project2::Project;
use settings2::Settings;
use project::Project;
use settings::Settings;
use std::{future::Future, mem, sync::Arc, time::Duration};
use util::{post_inc, ResultExt, TryFutureExt};
@ -72,8 +72,8 @@ pub struct Room {
client: Arc<Client>,
user_store: Model<UserStore>,
follows_by_leader_id_project_id: HashMap<(PeerId, u64), Vec<PeerId>>,
client_subscriptions: Vec<client2::Subscription>,
_subscriptions: Vec<gpui2::Subscription>,
client_subscriptions: Vec<client::Subscription>,
_subscriptions: Vec<gpui::Subscription>,
room_update_completed_tx: watch::Sender<Option<()>>,
room_update_completed_rx: watch::Receiver<Option<()>>,
pending_room_update: Option<Task<()>>,
@ -98,7 +98,7 @@ impl Room {
if let Some(live_kit) = self.live_kit.as_ref() {
matches!(
*live_kit.room.status().borrow(),
live_kit_client2::ConnectionState::Connected { .. }
live_kit_client::ConnectionState::Connected { .. }
)
} else {
false
@ -114,7 +114,7 @@ impl Room {
cx: &mut ModelContext<Self>,
) -> Self {
let live_kit_room = if let Some(connection_info) = live_kit_connection_info {
let room = live_kit_client2::Room::new();
let room = live_kit_client::Room::new();
let mut status = room.status();
// Consume the initial status of the room.
let _ = status.try_recv();
@ -126,7 +126,7 @@ impl Room {
break;
};
if status == live_kit_client2::ConnectionState::Disconnected {
if status == live_kit_client::ConnectionState::Disconnected {
this.update(&mut cx, |this, cx| this.leave(cx).log_err())
.ok();
break;
@ -341,7 +341,7 @@ impl Room {
}
pub fn mute_on_join(cx: &AppContext) -> bool {
CallSettings::get_global(cx).mute_on_join || client2::IMPERSONATE_LOGIN.is_some()
CallSettings::get_global(cx).mute_on_join || client::IMPERSONATE_LOGIN.is_some()
}
fn from_join_response(
@ -1504,7 +1504,7 @@ impl Room {
}
#[cfg(any(test, feature = "test-support"))]
pub fn set_display_sources(&self, sources: Vec<live_kit_client2::MacOSDisplay>) {
pub fn set_display_sources(&self, sources: Vec<live_kit_client::MacOSDisplay>) {
self.live_kit
.as_ref()
.unwrap()
@ -1514,7 +1514,7 @@ impl Room {
}
struct LiveKitRoom {
room: Arc<live_kit_client2::Room>,
room: Arc<live_kit_client::Room>,
screen_track: LocalTrack,
microphone_track: LocalTrack,
/// Tracks whether we're currently in a muted state due to auto-mute from deafening or manual mute performed by user.

18
crates/client2/Cargo.toml
View File

@ -9,17 +9,17 @@ path = "src/client2.rs"
doctest = false
[features]
test-support = ["collections/test-support", "gpui2/test-support", "rpc2/test-support"]
test-support = ["collections/test-support", "gpui/test-support", "rpc/test-support"]
[dependencies]
collections = { path = "../collections" }
db2 = { path = "../db2" }
gpui2 = { path = "../gpui2" }
db = { package = "db2", path = "../db2" }
gpui = { package = "gpui2", path = "../gpui2" }
util = { path = "../util" }
rpc2 = { path = "../rpc2" }
rpc = { package = "rpc2", path = "../rpc2" }
text = { path = "../text" }
settings2 = { path = "../settings2" }
feature_flags2 = { path = "../feature_flags2" }
settings = { package = "settings2", path = "../settings2" }
feature_flags = { package = "feature_flags2", path = "../feature_flags2" }
sum_tree = { path = "../sum_tree" }
anyhow.workspace = true
@ -46,7 +46,7 @@ url = "2.2"
[dev-dependencies]
collections = { path = "../collections", features = ["test-support"] }
gpui2 = { path = "../gpui2", features = ["test-support"] }
rpc2 = { path = "../rpc2", features = ["test-support"] }
settings = { path = "../settings", features = ["test-support"] }
gpui = { package = "gpui2", path = "../gpui2", features = ["test-support"] }
rpc = { package = "rpc2", path = "../rpc2", features = ["test-support"] }
settings = { package = "settings2", path = "../settings2", features = ["test-support"] }
util = { path = "../util", features = ["test-support"] }

28
crates/client2/src/client2.rs
View File

@ -14,7 +14,7 @@ use futures::{
future::LocalBoxFuture, AsyncReadExt, FutureExt, SinkExt, StreamExt, TryFutureExt as _,
TryStreamExt,
};
use gpui2::{
use gpui::{
serde_json, AnyModel, AnyWeakModel, AppContext, AsyncAppContext, Model, SemanticVersion, Task,
WeakModel,
};
@ -22,10 +22,10 @@ use lazy_static::lazy_static;
use parking_lot::RwLock;
use postage::watch;
use rand::prelude::*;
use rpc2::proto::{AnyTypedEnvelope, EntityMessage, EnvelopedMessage, PeerId, RequestMessage};
use rpc::proto::{AnyTypedEnvelope, EntityMessage, EnvelopedMessage, PeerId, RequestMessage};
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use settings2::Settings;
use settings::Settings;
use std::{
any::TypeId,
collections::HashMap,
@ -44,7 +44,7 @@ use util::channel::ReleaseChannel;
use util::http::HttpClient;
use util::{ResultExt, TryFutureExt};
pub use rpc2::*;
pub use rpc::*;
pub use telemetry::ClickhouseEvent;
pub use user::*;
@ -367,7 +367,7 @@ pub struct TelemetrySettingsContent {
pub metrics: Option<bool>,
}
impl settings2::Settings for TelemetrySettings {
impl settings::Settings for TelemetrySettings {
const KEY: Option<&'static str> = Some("telemetry");
type FileContent = TelemetrySettingsContent;
@ -979,7 +979,7 @@ impl Client {
"Authorization",
format!("{} {}", credentials.user_id, credentials.access_token),
)
.header("x-zed-protocol-version", rpc2::PROTOCOL_VERSION);
.header("x-zed-protocol-version", rpc::PROTOCOL_VERSION);
let http = self.http.clone();
cx.background_executor().spawn(async move {
@ -1029,7 +1029,7 @@ impl Client {
// zed server to encrypt the user's access token, so that it can'be intercepted by
// any other app running on the user's device.
let (public_key, private_key) =
rpc2::auth::keypair().expect("failed to generate keypair for auth");
rpc::auth::keypair().expect("failed to generate keypair for auth");
let public_key_string =
String::try_from(public_key).expect("failed to serialize public key for auth");
@ -1383,12 +1383,12 @@ mod tests {
use super::*;
use crate::test::FakeServer;
use gpui2::{BackgroundExecutor, Context, TestAppContext};
use gpui::{BackgroundExecutor, Context, TestAppContext};
use parking_lot::Mutex;
use std::future;
use util::http::FakeHttpClient;
#[gpui2::test(iterations = 10)]
#[gpui::test(iterations = 10)]
async fn test_reconnection(cx: &mut TestAppContext) {
let user_id = 5;
let client = cx.update(|cx| Client::new(FakeHttpClient::with_404_response(), cx));
@ -1422,7 +1422,7 @@ mod tests {
assert_eq!(server.auth_count(), 2); // Client re-authenticated due to an invalid token
}
#[gpui2::test(iterations = 10)]
#[gpui::test(iterations = 10)]
async fn test_connection_timeout(executor: BackgroundExecutor, cx: &mut TestAppContext) {
let user_id = 5;
let client = cx.update(|cx| Client::new(FakeHttpClient::with_404_response(), cx));
@ -1490,7 +1490,7 @@ mod tests {
));
}
#[gpui2::test(iterations = 10)]
#[gpui::test(iterations = 10)]
async fn test_authenticating_more_than_once(
cx: &mut TestAppContext,
executor: BackgroundExecutor,
@ -1541,7 +1541,7 @@ mod tests {
assert_eq!(decode_worktree_url("not://the-right-format"), None);
}
#[gpui2::test]
#[gpui::test]
async fn test_subscribing_to_entity(cx: &mut TestAppContext) {
let user_id = 5;
let client = cx.update(|cx| Client::new(FakeHttpClient::with_404_response(), cx));
@ -1594,7 +1594,7 @@ mod tests {
done_rx2.next().await.unwrap();
}
#[gpui2::test]
#[gpui::test]
async fn test_subscribing_after_dropping_subscription(cx: &mut TestAppContext) {
let user_id = 5;
let client = cx.update(|cx| Client::new(FakeHttpClient::with_404_response(), cx));
@ -1622,7 +1622,7 @@ mod tests {
done_rx2.next().await.unwrap();
}
#[gpui2::test]
#[gpui::test]
async fn test_dropping_subscription_in_handler(cx: &mut TestAppContext) {
let user_id = 5;
let client = cx.update(|cx| Client::new(FakeHttpClient::with_404_response(), cx));

4
crates/client2/src/telemetry.rs
View File

@ -1,9 +1,9 @@
use crate::{TelemetrySettings, ZED_SECRET_CLIENT_TOKEN, ZED_SERVER_URL};
use gpui2::{serde_json, AppContext, AppMetadata, BackgroundExecutor, Task};
use gpui::{serde_json, AppContext, AppMetadata, BackgroundExecutor, Task};
use lazy_static::lazy_static;
use parking_lot::Mutex;
use serde::Serialize;
use settings2::Settings;
use settings::Settings;
use std::{env, io::Write, mem, path::PathBuf, sync::Arc, time::Duration};
use sysinfo::{
CpuRefreshKind, Pid, PidExt, ProcessExt, ProcessRefreshKind, RefreshKind, System, SystemExt,

4
crates/client2/src/test.rs
View File

@ -1,9 +1,9 @@
use crate::{Client, Connection, Credentials, EstablishConnectionError, UserStore};
use anyhow::{anyhow, Result};
use futures::{stream::BoxStream, StreamExt};
use gpui2::{BackgroundExecutor, Context, Model, TestAppContext};
use gpui::{BackgroundExecutor, Context, Model, TestAppContext};
use parking_lot::Mutex;
use rpc2::{
use rpc::{
proto::{self, GetPrivateUserInfo, GetPrivateUserInfoResponse},
ConnectionId, Peer, Receipt, TypedEnvelope,
};

6
crates/client2/src/user.rs
View File

@ -1,11 +1,11 @@
use super::{proto, Client, Status, TypedEnvelope};
use anyhow::{anyhow, Context, Result};
use collections::{hash_map::Entry, HashMap, HashSet};
use feature_flags2::FeatureFlagAppExt;
use feature_flags::FeatureFlagAppExt;
use futures::{channel::mpsc, future, AsyncReadExt, Future, StreamExt};
use gpui2::{AsyncAppContext, EventEmitter, ImageData, Model, ModelContext, Task};
use gpui::{AsyncAppContext, EventEmitter, ImageData, Model, ModelContext, Task};
use postage::{sink::Sink, watch};
use rpc2::proto::{RequestMessage, UsersResponse};
use rpc::proto::{RequestMessage, UsersResponse};
use std::sync::{Arc, Weak};
use text::ReplicaId;
use util::http::HttpClient;

24
crates/copilot2/Cargo.toml
View File

@ -11,21 +11,21 @@ doctest = false
[features]
test-support = [
"collections/test-support",
"gpui2/test-support",
"language2/test-support",
"lsp2/test-support",
"settings2/test-support",
"gpui/test-support",
"language/test-support",
"lsp/test-support",
"settings/test-support",
"util/test-support",
]
[dependencies]
collections = { path = "../collections" }
context_menu = { path = "../context_menu" }
gpui2 = { path = "../gpui2" }
language2 = { path = "../language2" }
settings2 = { path = "../settings2" }
gpui = { package = "gpui2", path = "../gpui2" }
language = { package = "language2", path = "../language2" }
settings = { package = "settings2", path = "../settings2" }
theme = { path = "../theme" }
lsp2 = { path = "../lsp2" }
lsp = { package = "lsp2", path = "../lsp2" }
node_runtime = { path = "../node_runtime"}
util = { path = "../util" }
async-compression = { version = "0.3", features = ["gzip", "futures-bufread"] }
@ -42,9 +42,9 @@ parking_lot.workspace = true
clock = { path = "../clock" }
collections = { path = "../collections", features = ["test-support"] }
fs = { path = "../fs", features = ["test-support"] }
gpui2 = { path = "../gpui2", features = ["test-support"] }
language2 = { path = "../language2", features = ["test-support"] }
lsp2 = { path = "../lsp2", features = ["test-support"] }
gpui = { package = "gpui2", path = "../gpui2", features = ["test-support"] }
language = { package = "language2", path = "../language2", features = ["test-support"] }
lsp = { package = "lsp2", path = "../lsp2", features = ["test-support"] }
rpc = { path = "../rpc", features = ["test-support"] }
settings2 = { path = "../settings2", features = ["test-support"] }
settings = { package = "settings2", path = "../settings2", features = ["test-support"] }
util = { path = "../util", features = ["test-support"] }

70
crates/copilot2/src/copilot2.rs
View File

@ -6,20 +6,20 @@ use async_compression::futures::bufread::GzipDecoder;
use async_tar::Archive;
use collections::{HashMap, HashSet};
use futures::{channel::oneshot, future::Shared, Future, FutureExt, TryFutureExt};
use gpui2::{
use gpui::{
AppContext, AsyncAppContext, Context, Entity, EntityId, EventEmitter, Model, ModelContext,
Task, WeakModel,
};
use language2::{
use language::{
language_settings::{all_language_settings, language_settings},
point_from_lsp, point_to_lsp, Anchor, Bias, Buffer, BufferSnapshot, Language,
LanguageServerName, PointUtf16, ToPointUtf16,
};
use lsp2::{LanguageServer, LanguageServerBinary, LanguageServerId};
use lsp::{LanguageServer, LanguageServerBinary, LanguageServerId};
use node_runtime::NodeRuntime;
use parking_lot::Mutex;
use request::StatusNotification;
use settings2::SettingsStore;
use settings::SettingsStore;
use smol::{fs, io::BufReader, stream::StreamExt};
use std::{
ffi::OsString,
@ -172,11 +172,11 @@ impl Status {
}
struct RegisteredBuffer {
uri: lsp2::Url,
uri: lsp::Url,
language_id: String,
snapshot: BufferSnapshot,
snapshot_version: i32,
_subscriptions: [gpui2::Subscription; 2],
_subscriptions: [gpui::Subscription; 2],
pending_buffer_change: Task<Option<()>>,
}
@ -220,8 +220,8 @@ impl RegisteredBuffer {
let new_text = new_snapshot
.text_for_range(edit.new.start.1..edit.new.end.1)
.collect();
lsp2::TextDocumentContentChangeEvent {
range: Some(lsp2::Range::new(
lsp::TextDocumentContentChangeEvent {
range: Some(lsp::Range::new(
point_to_lsp(edit_start),
point_to_lsp(edit_end),
)),
@ -243,9 +243,9 @@ impl RegisteredBuffer {
buffer.snapshot = new_snapshot;
server
.lsp
.notify::<lsp2::notification::DidChangeTextDocument>(
lsp2::DidChangeTextDocumentParams {
text_document: lsp2::VersionedTextDocumentIdentifier::new(
.notify::<lsp::notification::DidChangeTextDocument>(
lsp::DidChangeTextDocumentParams {
text_document: lsp::VersionedTextDocumentIdentifier::new(
buffer.uri.clone(),
buffer.snapshot_version,
),
@ -280,7 +280,7 @@ pub struct Copilot {
server: CopilotServer,
buffers: HashSet<WeakModel<Buffer>>,
server_id: LanguageServerId,
_subscription: gpui2::Subscription,
_subscription: gpui::Subscription,
}
pub enum Event {
@ -608,13 +608,13 @@ impl Copilot {
registered_buffers
.entry(buffer.entity_id())
.or_insert_with(|| {
let uri: lsp2::Url = uri_for_buffer(buffer, cx);
let uri: lsp::Url = uri_for_buffer(buffer, cx);
let language_id = id_for_language(buffer.read(cx).language());
let snapshot = buffer.read(cx).snapshot();
server
.notify::<lsp2::notification::DidOpenTextDocument>(
lsp2::DidOpenTextDocumentParams {
text_document: lsp2::TextDocumentItem {
.notify::<lsp::notification::DidOpenTextDocument>(
lsp::DidOpenTextDocumentParams {
text_document: lsp::TextDocumentItem {
uri: uri.clone(),
language_id: language_id.clone(),
version: 0,
@ -647,29 +647,29 @@ impl Copilot {
fn handle_buffer_event(
&mut self,
buffer: Model<Buffer>,
event: &language2::Event,
event: &language::Event,
cx: &mut ModelContext<Self>,
) -> Result<()> {
if let Ok(server) = self.server.as_running() {
if let Some(registered_buffer) = server.registered_buffers.get_mut(&buffer.entity_id())
{
match event {
language2::Event::Edited => {
language::Event::Edited => {
let _ = registered_buffer.report_changes(&buffer, cx);
}
language2::Event::Saved => {
language::Event::Saved => {
server
.lsp
.notify::<lsp2::notification::DidSaveTextDocument>(
lsp2::DidSaveTextDocumentParams {
text_document: lsp2::TextDocumentIdentifier::new(
.notify::<lsp::notification::DidSaveTextDocument>(
lsp::DidSaveTextDocumentParams {
text_document: lsp::TextDocumentIdentifier::new(
registered_buffer.uri.clone(),
),
text: None,
},
)?;
}
language2::Event::FileHandleChanged | language2::Event::LanguageChanged => {
language::Event::FileHandleChanged | language::Event::LanguageChanged => {
let new_language_id = id_for_language(buffer.read(cx).language());
let new_uri = uri_for_buffer(&buffer, cx);
if new_uri != registered_buffer.uri
@ -679,16 +679,16 @@ impl Copilot {
registered_buffer.language_id = new_language_id;
server
.lsp
.notify::<lsp2::notification::DidCloseTextDocument>(
lsp2::DidCloseTextDocumentParams {
text_document: lsp2::TextDocumentIdentifier::new(old_uri),
.notify::<lsp::notification::DidCloseTextDocument>(
lsp::DidCloseTextDocumentParams {
text_document: lsp::TextDocumentIdentifier::new(old_uri),
},
)?;
server
.lsp
.notify::<lsp2::notification::DidOpenTextDocument>(
lsp2::DidOpenTextDocumentParams {
text_document: lsp2::TextDocumentItem::new(
.notify::<lsp::notification::DidOpenTextDocument>(
lsp::DidOpenTextDocumentParams {
text_document: lsp::TextDocumentItem::new(
registered_buffer.uri.clone(),
registered_buffer.language_id.clone(),
registered_buffer.snapshot_version,
@ -711,9 +711,9 @@ impl Copilot {
if let Some(buffer) = server.registered_buffers.remove(&buffer.entity_id()) {
server
.lsp
.notify::<lsp2::notification::DidCloseTextDocument>(
lsp2::DidCloseTextDocumentParams {
text_document: lsp2::TextDocumentIdentifier::new(buffer.uri),
.notify::<lsp::notification::DidCloseTextDocument>(
lsp::DidCloseTextDocumentParams {
text_document: lsp::TextDocumentIdentifier::new(buffer.uri),
},
)
.log_err();
@ -798,7 +798,7 @@ impl Copilot {
) -> Task<Result<Vec<Completion>>>
where
R: 'static
+ lsp2::request::Request<
+ lsp::request::Request<
Params = request::GetCompletionsParams,
Result = request::GetCompletionsResult,
>,
@ -926,9 +926,9 @@ fn id_for_language(language: Option<&Arc<Language>>) -> String {
}
}
fn uri_for_buffer(buffer: &Model<Buffer>, cx: &AppContext) -> lsp2::Url {
fn uri_for_buffer(buffer: &Model<Buffer>, cx: &AppContext) -> lsp::Url {
if let Some(file) = buffer.read(cx).file().and_then(|file| file.as_local()) {
lsp2::Url::from_file_path(file.abs_path(cx)).unwrap()
lsp::Url::from_file_path(file.abs_path(cx)).unwrap()
} else {
format!("buffer://{}", buffer.entity_id()).parse().unwrap()
}

30
crates/copilot2/src/request.rs
View File

@ -8,7 +8,7 @@ pub struct CheckStatusParams {
pub local_checks_only: bool,
}
impl lsp2::request::Request for CheckStatus {
impl lsp::request::Request for CheckStatus {
type Params = CheckStatusParams;
type Result = SignInStatus;
const METHOD: &'static str = "checkStatus";
@ -33,7 +33,7 @@ pub struct PromptUserDeviceFlow {
pub verification_uri: String,
}
impl lsp2::request::Request for SignInInitiate {
impl lsp::request::Request for SignInInitiate {
type Params = SignInInitiateParams;
type Result = SignInInitiateResult;
const METHOD: &'static str = "signInInitiate";
@ -66,7 +66,7 @@ pub enum SignInStatus {
NotSignedIn,
}
impl lsp2::request::Request for SignInConfirm {
impl lsp::request::Request for SignInConfirm {
type Params = SignInConfirmParams;
type Result = SignInStatus;
const METHOD: &'static str = "signInConfirm";
@ -82,7 +82,7 @@ pub struct SignOutParams {}
#[serde(rename_all = "camelCase")]
pub struct SignOutResult {}
impl lsp2::request::Request for SignOut {
impl lsp::request::Request for SignOut {
type Params = SignOutParams;
type Result = SignOutResult;
const METHOD: &'static str = "signOut";
@ -102,9 +102,9 @@ pub struct GetCompletionsDocument {
pub tab_size: u32,
pub indent_size: u32,
pub insert_spaces: bool,
pub uri: lsp2::Url,
pub uri: lsp::Url,
pub relative_path: String,
pub position: lsp2::Position,
pub position: lsp::Position,
pub version: usize,
}
@ -118,13 +118,13 @@ pub struct GetCompletionsResult {
#[serde(rename_all = "camelCase")]
pub struct Completion {
pub text: String,
pub position: lsp2::Position,
pub position: lsp::Position,
pub uuid: String,
pub range: lsp2::Range,
pub range: lsp::Range,
pub display_text: String,
}
impl lsp2::request::Request for GetCompletions {
impl lsp::request::Request for GetCompletions {
type Params = GetCompletionsParams;
type Result = GetCompletionsResult;
const METHOD: &'static str = "getCompletions";
@ -132,7 +132,7 @@ impl lsp2::request::Request for GetCompletions {
pub enum GetCompletionsCycling {}
impl lsp2::request::Request for GetCompletionsCycling {
impl lsp::request::Request for GetCompletionsCycling {
type Params = GetCompletionsParams;
type Result = GetCompletionsResult;
const METHOD: &'static str = "getCompletionsCycling";
@ -149,7 +149,7 @@ pub struct LogMessageParams {
pub extra: Vec<String>,
}
impl lsp2::notification::Notification for LogMessage {
impl lsp::notification::Notification for LogMessage {
type Params = LogMessageParams;
const METHOD: &'static str = "LogMessage";
}
@ -162,7 +162,7 @@ pub struct StatusNotificationParams {
pub status: String, // One of Normal/InProgress
}
impl lsp2::notification::Notification for StatusNotification {
impl lsp::notification::Notification for StatusNotification {
type Params = StatusNotificationParams;
const METHOD: &'static str = "statusNotification";
}
@ -176,7 +176,7 @@ pub struct SetEditorInfoParams {
pub editor_plugin_info: EditorPluginInfo,
}
impl lsp2::request::Request for SetEditorInfo {
impl lsp::request::Request for SetEditorInfo {
type Params = SetEditorInfoParams;
type Result = String;
const METHOD: &'static str = "setEditorInfo";
@ -204,7 +204,7 @@ pub struct NotifyAcceptedParams {
pub uuid: String,
}
impl lsp2::request::Request for NotifyAccepted {
impl lsp::request::Request for NotifyAccepted {
type Params = NotifyAcceptedParams;
type Result = String;
const METHOD: &'static str = "notifyAccepted";
@ -218,7 +218,7 @@ pub struct NotifyRejectedParams {
pub uuids: Vec<String>,
}
impl lsp2::request::Request for NotifyRejected {
impl lsp::request::Request for NotifyRejected {
type Params = NotifyRejectedParams;
type Result = String;
const METHOD: &'static str = "notifyRejected";

4
crates/db2/Cargo.toml
View File

@ -13,7 +13,7 @@ test-support = []
[dependencies]
collections = { path = "../collections" }
gpui2 = { path = "../gpui2" }
gpui = { package = "gpui2", path = "../gpui2" }
sqlez = { path = "../sqlez" }
sqlez_macros = { path = "../sqlez_macros" }
util = { path = "../util" }
@ -28,6 +28,6 @@ serde_derive.workspace = true
smol.workspace = true
[dev-dependencies]
gpui2 = { path = "../gpui2", features = ["test-support"] }
gpui = { package = "gpui2", path = "../gpui2", features = ["test-support"] }
env_logger.workspace = true
tempdir.workspace = true

12
crates/db2/src/db2.rs
View File

@ -4,7 +4,7 @@ pub mod query;
// Re-export
pub use anyhow;
use anyhow::Context;
use gpui2::AppContext;
use gpui::AppContext;
pub use indoc::indoc;
pub use lazy_static;
pub use smol;
@ -201,7 +201,7 @@ mod tests {
use crate::open_db;
// Test bad migration panics
#[gpui2::test]
#[gpui::test]
#[should_panic]
async fn test_bad_migration_panics() {
enum BadDB {}
@ -225,8 +225,8 @@ mod tests {
}
/// Test that DB exists but corrupted (causing recreate)
#[gpui2::test]
async fn test_db_corruption(cx: &mut gpui2::TestAppContext) {
#[gpui::test]
async fn test_db_corruption(cx: &mut gpui::TestAppContext) {
cx.executor().allow_parking();
enum CorruptedDB {}
@ -269,8 +269,8 @@ mod tests {
}
/// Test that DB exists but corrupted (causing recreate)
#[gpui2::test(iterations = 30)]
async fn test_simultaneous_db_corruption(cx: &mut gpui2::TestAppContext) {
#[gpui::test(iterations = 30)]
async fn test_simultaneous_db_corruption(cx: &mut gpui::TestAppContext) {
cx.executor().allow_parking();
enum CorruptedDB {}

2
crates/db2/src/kvp.rs
View File

@ -35,7 +35,7 @@ impl KeyValueStore {
mod tests {
use crate::kvp::KeyValueStore;
#[gpui2::test]
#[gpui::test]
async fn test_kvp() {
let db = KeyValueStore(crate::open_test_db("test_kvp").await);

2
crates/feature_flags2/Cargo.toml
View File

@ -8,5 +8,5 @@ publish = false
path = "src/feature_flags2.rs"
[dependencies]
gpui2 = { path = "../gpui2" }
gpui = { package = "gpui2", path = "../gpui2" }
anyhow.workspace = true

2
crates/feature_flags2/src/feature_flags2.rs
View File

@ -1,4 +1,4 @@
use gpui2::{AppContext, Subscription, ViewContext};
use gpui::{AppContext, Subscription, ViewContext};
#[derive(Default)]
struct FeatureFlags {

6
crates/fs2/Cargo.toml
View File

@ -31,10 +31,10 @@ log.workspace = true
libc = "0.2"
time.workspace = true
gpui2 = { path = "../gpui2", optional = true}
gpui = { package = "gpui2", path = "../gpui2", optional = true}
[dev-dependencies]
gpui2 = { path = "../gpui2", features = ["test-support"] }
gpui = { package = "gpui2", path = "../gpui2", features = ["test-support"] }
[features]
test-support = ["gpui2/test-support"]
test-support = ["gpui/test-support"]

8
crates/fs2/src/fs2.rs
View File

@ -288,7 +288,7 @@ impl Fs for RealFs {
pub struct FakeFs {
// Use an unfair lock to ensure tests are deterministic.
state: Mutex<FakeFsState>,
executor: gpui2::BackgroundExecutor,
executor: gpui::BackgroundExecutor,
}
#[cfg(any(test, feature = "test-support"))]
@ -434,7 +434,7 @@ lazy_static::lazy_static! {
#[cfg(any(test, feature = "test-support"))]
impl FakeFs {
pub fn new(executor: gpui2::BackgroundExecutor) -> Arc<Self> {
pub fn new(executor: gpui::BackgroundExecutor) -> Arc<Self> {
Arc::new(Self {
executor,
state: Mutex::new(FakeFsState {
@ -1222,10 +1222,10 @@ pub fn copy_recursive<'a>(
#[cfg(test)]
mod tests {
use super::*;
use gpui2::BackgroundExecutor;
use gpui::BackgroundExecutor;
use serde_json::json;
#[gpui2::test]
#[gpui::test]
async fn test_fake_fs(executor: BackgroundExecutor) {
let fs = FakeFs::new(executor.clone());
fs.insert_tree(

2
crates/fuzzy2/Cargo.toml
View File

@ -9,5 +9,5 @@ path = "src/fuzzy2.rs"
doctest = false
[dependencies]
gpui2 = { path = "../gpui2" }
gpui = { package = "gpui2", path = "../gpui2" }
util = { path = "../util" }

2
crates/fuzzy2/src/paths.rs
View File

@ -1,4 +1,4 @@
use gpui2::BackgroundExecutor;
use gpui::BackgroundExecutor;
use std::{
borrow::Cow,
cmp::{self, Ordering},

2
crates/fuzzy2/src/strings.rs
View File

@ -2,7 +2,7 @@ use crate::{
matcher::{Match, MatchCandidate, Matcher},
CharBag,
};
use gpui2::BackgroundExecutor;
use gpui::BackgroundExecutor;
use std::{
borrow::Cow,
cmp::{self, Ordering},

66
crates/gpui2/src/app.rs
View File

@ -5,6 +5,7 @@ mod model_context;
mod test_context;
pub use async_context::*;
use derive_more::{Deref, DerefMut};
pub use entity_map::*;
pub use model_context::*;
use refineable::Refineable;
@ -27,7 +28,7 @@ use parking_lot::Mutex;
use slotmap::SlotMap;
use std::{
any::{type_name, Any, TypeId},
cell::RefCell,
cell::{Ref, RefCell, RefMut},
marker::PhantomData,
mem,
ops::{Deref, DerefMut},
@ -38,7 +39,31 @@ use std::{
};
use util::http::{self, HttpClient};
pub struct App(Rc<RefCell<AppContext>>);
/// Temporary(?) wrapper around RefCell<AppContext> to help us debug any double borrows.
/// Strongly consider removing after stabilization.
pub struct AppCell {
app: RefCell<AppContext>,
}
impl AppCell {
pub fn borrow(&self) -> AppRef {
AppRef(self.app.borrow())
}
pub fn borrow_mut(&self) -> AppRefMut {
// let thread_id = std::thread::current().id();
// dbg!("borrowed {thread_id:?}");
AppRefMut(self.app.borrow_mut())
}
}
#[derive(Deref, DerefMut)]
pub struct AppRef<'a>(Ref<'a, AppContext>);
#[derive(Deref, DerefMut)]
pub struct AppRefMut<'a>(RefMut<'a, AppContext>);
pub struct App(Rc<AppCell>);
/// Represents an application before it is fully launched. Once your app is
/// configured, you'll start the app with `App::run`.
@ -112,14 +137,20 @@ impl App {
}
type ActionBuilder = fn(json: Option<serde_json::Value>) -> anyhow::Result<Box<dyn Action>>;
type FrameCallback = Box<dyn FnOnce(&mut WindowContext)>;
pub(crate) type FrameCallback = Box<dyn FnOnce(&mut AppContext)>;
type Handler = Box<dyn FnMut(&mut AppContext) -> bool + 'static>;
type Listener = Box<dyn FnMut(&dyn Any, &mut AppContext) -> bool + 'static>;
type QuitHandler = Box<dyn FnOnce(&mut AppContext) -> LocalBoxFuture<'static, ()> + 'static>;
type ReleaseListener = Box<dyn FnOnce(&mut dyn Any, &mut AppContext) + 'static>;
// struct FrameConsumer {
// next_frame_callbacks: Vec<FrameCallback>,
// task: Task<()>,
// display_linker
// }
pub struct AppContext {
this: Weak<RefCell<AppContext>>,
this: Weak<AppCell>,
pub(crate) platform: Rc<dyn Platform>,
app_metadata: AppMetadata,
text_system: Arc<TextSystem>,
@ -127,6 +158,7 @@ pub struct AppContext {
pending_updates: usize,
pub(crate) active_drag: Option<AnyDrag>,
pub(crate) next_frame_callbacks: HashMap<DisplayId, Vec<FrameCallback>>,
pub(crate) frame_consumers: HashMap<DisplayId, Task<()>>,
pub(crate) background_executor: BackgroundExecutor,
pub(crate) foreground_executor: ForegroundExecutor,
pub(crate) svg_renderer: SvgRenderer,
@ -157,7 +189,7 @@ impl AppContext {
platform: Rc<dyn Platform>,
asset_source: Arc<dyn AssetSource>,
http_client: Arc<dyn HttpClient>,
) -> Rc<RefCell<Self>> {
) -> Rc<AppCell> {
let executor = platform.background_executor();
let foreground_executor = platform.foreground_executor();
assert!(
@ -174,15 +206,17 @@ impl AppContext {
app_version: platform.app_version().ok(),
};
Rc::new_cyclic(|this| {
RefCell::new(AppContext {
Rc::new_cyclic(|this| AppCell {
app: RefCell::new(AppContext {
this: this.clone(),
text_system,
platform,
app_metadata,
text_system,
flushing_effects: false,
pending_updates: 0,
next_frame_callbacks: Default::default(),
active_drag: None,
next_frame_callbacks: HashMap::default(),
frame_consumers: HashMap::default(),
background_executor: executor,
foreground_executor,
svg_renderer: SvgRenderer::new(asset_source.clone()),
@ -205,8 +239,7 @@ impl AppContext {
quit_observers: SubscriberSet::new(),
layout_id_buffer: Default::default(),
propagate_event: true,
active_drag: None,
})
}),
})
}
@ -789,10 +822,13 @@ impl Context for AppContext {
let root_view = window.root_view.clone().unwrap();
let result = update(root_view, &mut WindowContext::new(cx, &mut window));
cx.windows
.get_mut(handle.id)
.ok_or_else(|| anyhow!("window not found"))?
.replace(window);
if !window.removed {
cx.windows
.get_mut(handle.id)
.ok_or_else(|| anyhow!("window not found"))?
.replace(window);
}
Ok(result)
})

10
crates/gpui2/src/app/async_context.rs
View File

@ -1,15 +1,15 @@
use crate::{
AnyView, AnyWindowHandle, AppContext, BackgroundExecutor, Context, ForegroundExecutor, Model,
ModelContext, Render, Result, Task, View, ViewContext, VisualContext, WindowContext,
AnyView, AnyWindowHandle, AppCell, AppContext, BackgroundExecutor, Context, ForegroundExecutor,
Model, ModelContext, Render, Result, Task, View, ViewContext, VisualContext, WindowContext,
WindowHandle,
};
use anyhow::{anyhow, Context as _};
use derive_more::{Deref, DerefMut};
use std::{cell::RefCell, future::Future, rc::Weak};
use std::{future::Future, rc::Weak};
#[derive(Clone)]
pub struct AsyncAppContext {
pub(crate) app: Weak<RefCell<AppContext>>,
pub(crate) app: Weak<AppCell>,
pub(crate) background_executor: BackgroundExecutor,
pub(crate) foreground_executor: ForegroundExecutor,
}
@ -121,7 +121,7 @@ impl AsyncAppContext {
.app
.upgrade()
.ok_or_else(|| anyhow!("app was released"))?;
let app = app.borrow_mut(); // Need this to compile
let app = app.borrow_mut();
Ok(read(app.global(), &app))
}

6
crates/gpui2/src/app/test_context.rs
View File

@ -1,15 +1,15 @@
use crate::{
AnyView, AnyWindowHandle, AppContext, AsyncAppContext, BackgroundExecutor, Context,
AnyView, AnyWindowHandle, AppCell, AppContext, AsyncAppContext, BackgroundExecutor, Context,
EventEmitter, ForegroundExecutor, Model, ModelContext, Result, Task, TestDispatcher,
TestPlatform, WindowContext,
};
use anyhow::{anyhow, bail};
use futures::{Stream, StreamExt};
use std::{cell::RefCell, future::Future, rc::Rc, sync::Arc, time::Duration};
use std::{future::Future, rc::Rc, sync::Arc, time::Duration};
#[derive(Clone)]
pub struct TestAppContext {
pub app: Rc<RefCell<AppContext>>,
pub app: Rc<AppCell>,
pub background_executor: BackgroundExecutor,
pub foreground_executor: ForegroundExecutor,
}

4
crates/gpui2/src/elements/img.rs
View File

@ -109,7 +109,9 @@ where
let corner_radii = style.corner_radii;
if let Some(uri) = self.uri.clone() {
let image_future = cx.image_cache.get(uri);
// eprintln!(">>> image_cache.get({uri}");
let image_future = cx.image_cache.get(uri.clone());
// eprintln!("<<< image_cache.get({uri}");
if let Some(data) = image_future
.clone()
.now_or_never()

2
crates/gpui2/src/platform.rs
View File

@ -69,7 +69,7 @@ pub(crate) trait Platform: 'static {
fn set_display_link_output_callback(
&self,
display_id: DisplayId,
callback: Box<dyn FnMut(&VideoTimestamp, &VideoTimestamp)>,
callback: Box<dyn FnMut(&VideoTimestamp, &VideoTimestamp) + Send>,
);
fn start_display_link(&self, display_id: DisplayId);
fn stop_display_link(&self, display_id: DisplayId);

4
crates/gpui2/src/platform/mac/display_linker.rs
View File

@ -26,13 +26,13 @@ impl MacDisplayLinker {
}
}
type OutputCallback = Mutex<Box<dyn FnMut(&VideoTimestamp, &VideoTimestamp)>>;
type OutputCallback = Mutex<Box<dyn FnMut(&VideoTimestamp, &VideoTimestamp) + Send>>;
impl MacDisplayLinker {
pub fn set_output_callback(
&mut self,
display_id: DisplayId,
output_callback: Box<dyn FnMut(&VideoTimestamp, &VideoTimestamp)>,
output_callback: Box<dyn FnMut(&VideoTimestamp, &VideoTimestamp) + Send>,
) {
if let Some(mut system_link) = unsafe { sys::DisplayLink::on_display(display_id.0) } {
let callback = Arc::new(Mutex::new(output_callback));

2
crates/gpui2/src/platform/mac/platform.rs
View File

@ -494,7 +494,7 @@ impl Platform for MacPlatform {
fn set_display_link_output_callback(
&self,
display_id: DisplayId,
callback: Box<dyn FnMut(&VideoTimestamp, &VideoTimestamp)>,
callback: Box<dyn FnMut(&VideoTimestamp, &VideoTimestamp) + Send>,
) {
self.0
.lock()

6
crates/gpui2/src/platform/mac/shaders.metal
View File

@ -98,10 +98,10 @@ fragment float4 quad_fragment(QuadVertexOutput input [[stage_in]],
input.border_color.a *= 1. - saturate(0.5 - inset_distance);
// Alpha-blend the border and the background.
float output_alpha =
quad.border_color.a + quad.background.a * (1. - quad.border_color.a);
float output_alpha = input.border_color.a +
input.background_color.a * (1. - input.border_color.a);
float3 premultiplied_border_rgb =
input.border_color.rgb * quad.border_color.a;
input.border_color.rgb * input.border_color.a;
float3 premultiplied_background_rgb =
input.background_color.rgb * input.background_color.a;
float3 premultiplied_output_rgb =

33
crates/gpui2/src/platform/mac/window.rs
View File

@ -678,10 +678,15 @@ impl MacWindow {
impl Drop for MacWindow {
fn drop(&mut self) {
let native_window = self.0.lock().native_window;
unsafe {
native_window.close();
}
let this = self.0.lock();
let window = this.native_window;
this.executor
.spawn(async move {
unsafe {
window.close();
}
})
.detach();
}
}
@ -868,17 +873,25 @@ impl PlatformWindow for MacWindow {
fn zoom(&self) {
let this = self.0.lock();
let window = this.native_window;
unsafe {
window.zoom_(nil);
}
this.executor
.spawn(async move {
unsafe {
window.zoom_(nil);
}
})
.detach();
}
fn toggle_full_screen(&self) {
let this = self.0.lock();
let window = this.native_window;
unsafe {
window.toggleFullScreen_(nil);
}
this.executor
.spawn(async move {
unsafe {
window.toggleFullScreen_(nil);
}
})
.detach();
}
fn on_input(&self, callback: Box<dyn FnMut(InputEvent) -> bool>) {

2
crates/gpui2/src/platform/test/platform.rs
View File

@ -81,7 +81,7 @@ impl Platform for TestPlatform {
fn set_display_link_output_callback(
&self,
_display_id: DisplayId,
_callback: Box<dyn FnMut(&crate::VideoTimestamp, &crate::VideoTimestamp)>,
_callback: Box<dyn FnMut(&crate::VideoTimestamp, &crate::VideoTimestamp) + Send>,
) {
unimplemented!()
}

93
crates/gpui2/src/window.rs
View File

@ -4,16 +4,19 @@ use crate::{
Entity, EntityId, EventEmitter, FileDropEvent, FocusEvent, FontId, GlobalElementId, GlyphId,
Hsla, ImageData, InputEvent, IsZero, KeyListener, KeyMatch, KeyMatcher, Keystroke, LayoutId,
Model, ModelContext, Modifiers, MonochromeSprite, MouseButton, MouseDownEvent, MouseMoveEvent,
MouseUpEvent, Path, Pixels, PlatformAtlas, PlatformWindow, Point, PolychromeSprite,
PromptLevel, Quad, Render, RenderGlyphParams, RenderImageParams, RenderSvgParams, ScaledPixels,
SceneBuilder, Shadow, SharedString, Size, Style, SubscriberSet, Subscription,
TaffyLayoutEngine, Task, Underline, UnderlineStyle, View, VisualContext, WeakView,
WindowBounds, WindowOptions, SUBPIXEL_VARIANTS,
MouseUpEvent, Path, Pixels, PlatformAtlas, PlatformDisplay, PlatformWindow, Point,
PolychromeSprite, PromptLevel, Quad, Render, RenderGlyphParams, RenderImageParams,
RenderSvgParams, ScaledPixels, SceneBuilder, Shadow, SharedString, Size, Style, SubscriberSet,
Subscription, TaffyLayoutEngine, Task, Underline, UnderlineStyle, View, VisualContext,
WeakView, WindowBounds, WindowOptions, SUBPIXEL_VARIANTS,
};
use anyhow::{anyhow, Result};
use collections::HashMap;
use derive_more::{Deref, DerefMut};
use futures::channel::oneshot;
use futures::{
channel::{mpsc, oneshot},
StreamExt,
};
use parking_lot::RwLock;
use slotmap::SlotMap;
use smallvec::SmallVec;
@ -25,6 +28,7 @@ use std::{
hash::{Hash, Hasher},
marker::PhantomData,
mem,
rc::Rc,
sync::{
atomic::{AtomicUsize, Ordering::SeqCst},
Arc,
@ -161,6 +165,7 @@ impl Drop for FocusHandle {
// Holds the state for a specific window.
pub struct Window {
pub(crate) handle: AnyWindowHandle,
pub(crate) removed: bool,
platform_window: Box<dyn PlatformWindow>,
display_id: DisplayId,
sprite_atlas: Arc<dyn PlatformAtlas>,
@ -253,6 +258,7 @@ impl Window {
Window {
handle,
removed: false,
platform_window,
display_id,
sprite_atlas,
@ -348,6 +354,11 @@ impl<'a> WindowContext<'a> {
self.window.dirty = true;
}
/// Close this window.
pub fn remove_window(&mut self) {
self.window.removed = true;
}
/// Obtain a new `FocusHandle`, which allows you to track and manipulate the keyboard focus
/// for elements rendered within this window.
pub fn focus_handle(&mut self) -> FocusHandle {
@ -435,42 +446,55 @@ impl<'a> WindowContext<'a> {
}
/// Schedule the given closure to be run directly after the current frame is rendered.
pub fn on_next_frame(&mut self, f: impl FnOnce(&mut WindowContext) + 'static) {
let f = Box::new(f);
pub fn on_next_frame(&mut self, callback: impl FnOnce(&mut WindowContext) + 'static) {
let handle = self.window.handle;
let display_id = self.window.display_id;
if let Some(callbacks) = self.next_frame_callbacks.get_mut(&display_id) {
callbacks.push(f);
// If there was already a callback, it means that we already scheduled a frame.
if callbacks.len() > 1 {
return;
}
} else {
let mut async_cx = self.to_async();
self.next_frame_callbacks.insert(display_id, vec![f]);
if !self.frame_consumers.contains_key(&display_id) {
let (tx, mut rx) = mpsc::unbounded::<()>();
self.platform.set_display_link_output_callback(
display_id,
Box::new(move |_current_time, _output_time| {
let _ = async_cx.update(|_, cx| {
let callbacks = cx
Box::new(move |_current_time, _output_time| _ = tx.unbounded_send(())),
);
let consumer_task = self.app.spawn(|cx| async move {
while rx.next().await.is_some() {
cx.update(|cx| {
for callback in cx
.next_frame_callbacks
.get_mut(&display_id)
.unwrap()
.drain(..)
.collect::<Vec<_>>();
for callback in callbacks {
.collect::<SmallVec<[_; 32]>>()
{
callback(cx);
}
})
.ok();
if cx.next_frame_callbacks.get(&display_id).unwrap().is_empty() {
// Flush effects, then stop the display link if no new next_frame_callbacks have been added.
cx.update(|cx| {
if cx.next_frame_callbacks.is_empty() {
cx.platform.stop_display_link(display_id);
}
});
}),
);
})
.ok();
}
});
self.frame_consumers.insert(display_id, consumer_task);
}
self.platform.start_display_link(display_id);
if self.next_frame_callbacks.is_empty() {
self.platform.start_display_link(display_id);
}
self.next_frame_callbacks
.entry(display_id)
.or_default()
.push(Box::new(move |cx: &mut AppContext| {
cx.update_window(handle, |_root_view, cx| callback(cx)).ok();
}));
}
/// Spawn the future returned by the given closure on the application thread pool.
@ -563,6 +587,21 @@ impl<'a> WindowContext<'a> {
self.window.bounds
}
pub fn is_window_active(&self) -> bool {
self.window.active
}
pub fn zoom_window(&self) {
self.window.platform_window.zoom();
}
pub fn display(&self) -> Option<Rc<dyn PlatformDisplay>> {
self.platform
.displays()
.into_iter()
.find(|display| display.id() == self.window.display_id)
}
/// The scale factor of the display associated with the window. For example, it could
/// return 2.0 for a "retina" display, indicating that each logical pixel should actually
/// be rendered as two pixels on screen.

14
crates/gpui2_macros/src/test.rs
View File

@ -90,7 +90,7 @@ pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
continue;
}
Some("BackgroundExecutor") => {
inner_fn_args.extend(quote!(gpui2::BackgroundExecutor::new(
inner_fn_args.extend(quote!(gpui::BackgroundExecutor::new(
std::sync::Arc::new(dispatcher.clone()),
),));
continue;
@ -105,7 +105,7 @@ pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
{
let cx_varname = format_ident!("cx_{}", ix);
cx_vars.extend(quote!(
let mut #cx_varname = gpui2::TestAppContext::new(
let mut #cx_varname = gpui::TestAppContext::new(
dispatcher.clone()
);
));
@ -130,11 +130,11 @@ pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
fn #outer_fn_name() {
#inner_fn
gpui2::run_test(
gpui::run_test(
#num_iterations as u64,
#max_retries,
&mut |dispatcher, _seed| {
let executor = gpui2::BackgroundExecutor::new(std::sync::Arc::new(dispatcher.clone()));
let executor = gpui::BackgroundExecutor::new(std::sync::Arc::new(dispatcher.clone()));
#cx_vars
executor.block_test(#inner_fn_name(#inner_fn_args));
#cx_teardowns
@ -167,7 +167,7 @@ pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
let cx_varname = format_ident!("cx_{}", ix);
let cx_varname_lock = format_ident!("cx_{}_lock", ix);
cx_vars.extend(quote!(
let mut #cx_varname = gpui2::TestAppContext::new(
let mut #cx_varname = gpui::TestAppContext::new(
dispatcher.clone()
);
let mut #cx_varname_lock = #cx_varname.app.borrow_mut();
@ -182,7 +182,7 @@ pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
Some("TestAppContext") => {
let cx_varname = format_ident!("cx_{}", ix);
cx_vars.extend(quote!(
let mut #cx_varname = gpui2::TestAppContext::new(
let mut #cx_varname = gpui::TestAppContext::new(
dispatcher.clone()
);
));
@ -209,7 +209,7 @@ pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
fn #outer_fn_name() {
#inner_fn
gpui2::run_test(
gpui::run_test(
#num_iterations as u64,
#max_retries,
&mut |dispatcher, _seed| {

2
crates/install_cli2/Cargo.toml
View File

@ -14,5 +14,5 @@ test-support = []
smol.workspace = true
anyhow.workspace = true
log.workspace = true
gpui2 = { path = "../gpui2" }
gpui = { package = "gpui2", path = "../gpui2" }
util = { path = "../util" }

2
crates/install_cli2/src/install_cli2.rs
View File

@ -1,5 +1,5 @@
use anyhow::{anyhow, Result};
use gpui2::AsyncAppContext;
use gpui::AsyncAppContext;
use std::path::Path;
use util::ResultExt;

2
crates/journal2/Cargo.toml
View File

@ -10,7 +10,7 @@ doctest = false
[dependencies]
editor = { path = "../editor" }
gpui2 = { path = "../gpui2" }
gpui = { package = "gpui2", path = "../gpui2" }
util = { path = "../util" }
workspace = { path = "../workspace" }
settings2 = { path = "../settings2" }

2
crates/journal2/src/journal2.rs
View File

@ -1,6 +1,6 @@
use anyhow::Result;
use chrono::{Datelike, Local, NaiveTime, Timelike};
use gpui2::AppContext;
use gpui::AppContext;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use settings2::Settings;

26
crates/language2/Cargo.toml
View File

@ -11,28 +11,28 @@ doctest = false
[features]
test-support = [
"rand",
"client2/test-support",
"client/test-support",
"collections/test-support",
"lsp2/test-support",
"lsp/test-support",
"text/test-support",
"tree-sitter-rust",
"tree-sitter-typescript",
"settings2/test-support",
"settings/test-support",
"util/test-support",
]
[dependencies]
clock = { path = "../clock" }
collections = { path = "../collections" }
fuzzy2 = { path = "../fuzzy2" }
fuzzy = { package = "fuzzy2", path = "../fuzzy2" }
git = { path = "../git" }
gpui2 = { path = "../gpui2" }
lsp2 = { path = "../lsp2" }
rpc2 = { path = "../rpc2" }
settings2 = { path = "../settings2" }
gpui = { package = "gpui2", path = "../gpui2" }
lsp = { package = "lsp2", path = "../lsp2" }
rpc = { package = "rpc2", path = "../rpc2" }
settings = { package = "settings2", path = "../settings2" }
sum_tree = { path = "../sum_tree" }
text = { path = "../text" }
theme2 = { path = "../theme2" }
theme = { package = "theme2", path = "../theme2" }
util = { path = "../util" }
anyhow.workspace = true
@ -60,12 +60,12 @@ tree-sitter-rust = { workspace = true, optional = true }
tree-sitter-typescript = { workspace = true, optional = true }
[dev-dependencies]
client2 = { path = "../client2", features = ["test-support"] }
client = { package = "client2", path = "../client2", features = ["test-support"] }
collections = { path = "../collections", features = ["test-support"] }
gpui2 = { path = "../gpui2", features = ["test-support"] }
lsp2 = { path = "../lsp2", features = ["test-support"] }
gpui = { package = "gpui2", path = "../gpui2", features = ["test-support"] }
lsp = { package = "lsp2", path = "../lsp2", features = ["test-support"] }
text = { path = "../text", features = ["test-support"] }
settings2 = { path = "../settings2", features = ["test-support"] }
settings = { package = "settings2", path = "../settings2", features = ["test-support"] }
util = { path = "../util", features = ["test-support"] }
ctor.workspace = true
env_logger.workspace = true

20
crates/language2/src/buffer.rs
View File

@ -16,8 +16,8 @@ use crate::{
use anyhow::{anyhow, Result};
pub use clock::ReplicaId;
use futures::FutureExt as _;
use gpui2::{AppContext, EventEmitter, HighlightStyle, ModelContext, Task};
use lsp2::LanguageServerId;
use gpui::{AppContext, EventEmitter, HighlightStyle, ModelContext, Task};
use lsp::LanguageServerId;
use parking_lot::Mutex;
use similar::{ChangeTag, TextDiff};
use smallvec::SmallVec;
@ -40,7 +40,7 @@ use std::{
use sum_tree::TreeMap;
use text::operation_queue::OperationQueue;
pub use text::{Buffer as TextBuffer, BufferSnapshot as TextBufferSnapshot, *};
use theme2::SyntaxTheme;
use theme::SyntaxTheme;
#[cfg(any(test, feature = "test-support"))]
use util::RandomCharIter;
use util::{RangeExt, TryFutureExt as _};
@ -48,7 +48,7 @@ use util::{RangeExt, TryFutureExt as _};
#[cfg(any(test, feature = "test-support"))]
pub use {tree_sitter_rust, tree_sitter_typescript};
pub use lsp2::DiagnosticSeverity;
pub use lsp::DiagnosticSeverity;
pub struct Buffer {
text: TextBuffer,
@ -149,14 +149,14 @@ pub struct Completion {
pub new_text: String,
pub label: CodeLabel,
pub server_id: LanguageServerId,
pub lsp_completion: lsp2::CompletionItem,
pub lsp_completion: lsp::CompletionItem,
}
#[derive(Clone, Debug)]
pub struct CodeAction {
pub server_id: LanguageServerId,
pub range: Range<Anchor>,
pub lsp_action: lsp2::CodeAction,
pub lsp_action: lsp::CodeAction,
}
#[derive(Clone, Debug, PartialEq)]
@ -226,7 +226,7 @@ pub trait File: Send + Sync {
fn as_any(&self) -> &dyn Any;
fn to_proto(&self) -> rpc2::proto::File;
fn to_proto(&self) -> rpc::proto::File;
}
pub trait LocalFile: File {
@ -375,7 +375,7 @@ impl Buffer {
file,
);
this.text.set_line_ending(proto::deserialize_line_ending(
rpc2::proto::LineEnding::from_i32(message.line_ending)
rpc::proto::LineEnding::from_i32(message.line_ending)
.ok_or_else(|| anyhow!("missing line_ending"))?,
));
this.saved_version = proto::deserialize_version(&message.saved_version);
@ -3003,14 +3003,14 @@ impl IndentSize {
impl Completion {
pub fn sort_key(&self) -> (usize, &str) {
let kind_key = match self.lsp_completion.kind {
Some(lsp2::CompletionItemKind::VARIABLE) => 0,
Some(lsp::CompletionItemKind::VARIABLE) => 0,
_ => 1,
};
(kind_key, &self.label.text[self.label.filter_range.clone()])
}
pub fn is_snippet(&self) -> bool {
self.lsp_completion.insert_text_format == Some(lsp2::InsertTextFormat::SNIPPET)
self.lsp_completion.insert_text_format == Some(lsp::InsertTextFormat::SNIPPET)
}
}

94
crates/language2/src/buffer_tests.rs
View File

@ -5,13 +5,13 @@ use crate::language_settings::{
use crate::Buffer;
use clock::ReplicaId;
use collections::BTreeMap;
use gpui2::{AppContext, Model};
use gpui2::{Context, TestAppContext};
use gpui::{AppContext, Model};
use gpui::{Context, TestAppContext};
use indoc::indoc;
use proto::deserialize_operation;
use rand::prelude::*;
use regex::RegexBuilder;
use settings2::SettingsStore;
use settings::SettingsStore;
use std::{
env,
ops::Range,
@ -38,8 +38,8 @@ fn init_logger() {
}
}
#[gpui2::test]
fn test_line_endings(cx: &mut gpui2::AppContext) {
#[gpui::test]
fn test_line_endings(cx: &mut gpui::AppContext) {
init_settings(cx, |_| {});
cx.build_model(|cx| {
@ -63,7 +63,7 @@ fn test_line_endings(cx: &mut gpui2::AppContext) {
});
}
#[gpui2::test]
#[gpui::test]
fn test_select_language() {
let registry = Arc::new(LanguageRegistry::test());
registry.add(Arc::new(Language::new(
@ -132,8 +132,8 @@ fn test_select_language() {
);
}
#[gpui2::test]
fn test_edit_events(cx: &mut gpui2::AppContext) {
#[gpui::test]
fn test_edit_events(cx: &mut gpui::AppContext) {
let mut now = Instant::now();
let buffer_1_events = Arc::new(Mutex::new(Vec::new()));
let buffer_2_events = Arc::new(Mutex::new(Vec::new()));
@ -215,7 +215,7 @@ fn test_edit_events(cx: &mut gpui2::AppContext) {
);
}
#[gpui2::test]
#[gpui::test]
async fn test_apply_diff(cx: &mut TestAppContext) {
let text = "a\nbb\nccc\ndddd\neeeee\nffffff\n";
let buffer = cx.build_model(|cx| Buffer::new(0, cx.entity_id().as_u64(), text));
@ -238,8 +238,8 @@ async fn test_apply_diff(cx: &mut TestAppContext) {
});
}
#[gpui2::test(iterations = 10)]
async fn test_normalize_whitespace(cx: &mut gpui2::TestAppContext) {
#[gpui::test(iterations = 10)]
async fn test_normalize_whitespace(cx: &mut gpui::TestAppContext) {
let text = [
"zero", //
"one ", // 2 trailing spaces
@ -311,8 +311,8 @@ async fn test_normalize_whitespace(cx: &mut gpui2::TestAppContext) {
});
}
#[gpui2::test]
async fn test_reparse(cx: &mut gpui2::TestAppContext) {
#[gpui::test]
async fn test_reparse(cx: &mut gpui::TestAppContext) {
let text = "fn a() {}";
let buffer = cx.build_model(|cx| {
Buffer::new(0, cx.entity_id().as_u64(), text).with_language(Arc::new(rust_lang()), cx)
@ -440,8 +440,8 @@ async fn test_reparse(cx: &mut gpui2::TestAppContext) {
);
}
#[gpui2::test]
async fn test_resetting_language(cx: &mut gpui2::TestAppContext) {
#[gpui::test]
async fn test_resetting_language(cx: &mut gpui::TestAppContext) {
let buffer = cx.build_model(|cx| {
let mut buffer =
Buffer::new(0, cx.entity_id().as_u64(), "{}").with_language(Arc::new(rust_lang()), cx);
@ -463,8 +463,8 @@ async fn test_resetting_language(cx: &mut gpui2::TestAppContext) {
assert_eq!(get_tree_sexp(&buffer, cx), "(document (object))");
}
#[gpui2::test]
async fn test_outline(cx: &mut gpui2::TestAppContext) {
#[gpui::test]
async fn test_outline(cx: &mut gpui::TestAppContext) {
let text = r#"
struct Person {
name: String,
@ -556,7 +556,7 @@ async fn test_outline(cx: &mut gpui2::TestAppContext) {
async fn search<'a>(
outline: &'a Outline<Anchor>,
query: &'a str,
cx: &'a gpui2::TestAppContext,
cx: &'a gpui::TestAppContext,
) -> Vec<(&'a str, Vec<usize>)> {
let matches = cx
.update(|cx| outline.search(query, cx.background_executor().clone()))
@ -568,8 +568,8 @@ async fn test_outline(cx: &mut gpui2::TestAppContext) {
}
}
#[gpui2::test]
async fn test_outline_nodes_with_newlines(cx: &mut gpui2::TestAppContext) {
#[gpui::test]
async fn test_outline_nodes_with_newlines(cx: &mut gpui::TestAppContext) {
let text = r#"
impl A for B<
C
@ -595,8 +595,8 @@ async fn test_outline_nodes_with_newlines(cx: &mut gpui2::TestAppContext) {
);
}
#[gpui2::test]
async fn test_outline_with_extra_context(cx: &mut gpui2::TestAppContext) {
#[gpui::test]
async fn test_outline_with_extra_context(cx: &mut gpui::TestAppContext) {
let language = javascript_lang()
.with_outline_query(
r#"
@ -643,8 +643,8 @@ async fn test_outline_with_extra_context(cx: &mut gpui2::TestAppContext) {
);
}
#[gpui2::test]
async fn test_symbols_containing(cx: &mut gpui2::TestAppContext) {
#[gpui::test]
async fn test_symbols_containing(cx: &mut gpui::TestAppContext) {
let text = r#"
impl Person {
fn one() {
@ -731,7 +731,7 @@ async fn test_symbols_containing(cx: &mut gpui2::TestAppContext) {
}
}
#[gpui2::test]
#[gpui::test]
fn test_enclosing_bracket_ranges(cx: &mut AppContext) {
let mut assert = |selection_text, range_markers| {
assert_bracket_pairs(selection_text, range_markers, rust_lang(), cx)
@ -847,7 +847,7 @@ fn test_enclosing_bracket_ranges(cx: &mut AppContext) {
);
}
#[gpui2::test]
#[gpui::test]
fn test_enclosing_bracket_ranges_where_brackets_are_not_outermost_children(cx: &mut AppContext) {
let mut assert = |selection_text, bracket_pair_texts| {
assert_bracket_pairs(selection_text, bracket_pair_texts, javascript_lang(), cx)
@ -879,7 +879,7 @@ fn test_enclosing_bracket_ranges_where_brackets_are_not_outermost_children(cx: &
);
}
#[gpui2::test]
#[gpui::test]
fn test_range_for_syntax_ancestor(cx: &mut AppContext) {
cx.build_model(|cx| {
let text = "fn a() { b(|c| {}) }";
@ -918,7 +918,7 @@ fn test_range_for_syntax_ancestor(cx: &mut AppContext) {
}
}
#[gpui2::test]
#[gpui::test]
fn test_autoindent_with_soft_tabs(cx: &mut AppContext) {
init_settings(cx, |_| {});
@ -959,7 +959,7 @@ fn test_autoindent_with_soft_tabs(cx: &mut AppContext) {
});
}
#[gpui2::test]
#[gpui::test]
fn test_autoindent_with_hard_tabs(cx: &mut AppContext) {
init_settings(cx, |settings| {
settings.defaults.hard_tabs = Some(true);
@ -1002,7 +1002,7 @@ fn test_autoindent_with_hard_tabs(cx: &mut AppContext) {
});
}
#[gpui2::test]
#[gpui::test]
fn test_autoindent_does_not_adjust_lines_with_unchanged_suggestion(cx: &mut AppContext) {
init_settings(cx, |_| {});
@ -1143,7 +1143,7 @@ fn test_autoindent_does_not_adjust_lines_with_unchanged_suggestion(cx: &mut AppC
eprintln!("DONE");
}
#[gpui2::test]
#[gpui::test]
fn test_autoindent_does_not_adjust_lines_within_newly_created_errors(cx: &mut AppContext) {
init_settings(cx, |_| {});
@ -1205,7 +1205,7 @@ fn test_autoindent_does_not_adjust_lines_within_newly_created_errors(cx: &mut Ap
});
}
#[gpui2::test]
#[gpui::test]
fn test_autoindent_adjusts_lines_when_only_text_changes(cx: &mut AppContext) {
init_settings(cx, |_| {});
@ -1262,7 +1262,7 @@ fn test_autoindent_adjusts_lines_when_only_text_changes(cx: &mut AppContext) {
});
}
#[gpui2::test]
#[gpui::test]
fn test_autoindent_with_edit_at_end_of_buffer(cx: &mut AppContext) {
init_settings(cx, |_| {});
@ -1280,7 +1280,7 @@ fn test_autoindent_with_edit_at_end_of_buffer(cx: &mut AppContext) {
});
}
#[gpui2::test]
#[gpui::test]
fn test_autoindent_multi_line_insertion(cx: &mut AppContext) {
init_settings(cx, |_| {});
@ -1322,7 +1322,7 @@ fn test_autoindent_multi_line_insertion(cx: &mut AppContext) {
});
}
#[gpui2::test]
#[gpui::test]
fn test_autoindent_block_mode(cx: &mut AppContext) {
init_settings(cx, |_| {});
@ -1406,7 +1406,7 @@ fn test_autoindent_block_mode(cx: &mut AppContext) {
});
}
#[gpui2::test]
#[gpui::test]
fn test_autoindent_block_mode_without_original_indent_columns(cx: &mut AppContext) {
init_settings(cx, |_| {});
@ -1486,7 +1486,7 @@ fn test_autoindent_block_mode_without_original_indent_columns(cx: &mut AppContex
});
}
#[gpui2::test]
#[gpui::test]
fn test_autoindent_language_without_indents_query(cx: &mut AppContext) {
init_settings(cx, |_| {});
@ -1530,7 +1530,7 @@ fn test_autoindent_language_without_indents_query(cx: &mut AppContext) {
});
}
#[gpui2::test]
#[gpui::test]
fn test_autoindent_with_injected_languages(cx: &mut AppContext) {
init_settings(cx, |settings| {
settings.languages.extend([
@ -1604,7 +1604,7 @@ fn test_autoindent_with_injected_languages(cx: &mut AppContext) {
});
}
#[gpui2::test]
#[gpui::test]
fn test_autoindent_query_with_outdent_captures(cx: &mut AppContext) {
init_settings(cx, |settings| {
settings.defaults.tab_size = Some(2.try_into().unwrap());
@ -1649,7 +1649,7 @@ fn test_autoindent_query_with_outdent_captures(cx: &mut AppContext) {
});
}
#[gpui2::test]
#[gpui::test]
fn test_language_scope_at_with_javascript(cx: &mut AppContext) {
init_settings(cx, |_| {});
@ -1738,7 +1738,7 @@ fn test_language_scope_at_with_javascript(cx: &mut AppContext) {
});
}
#[gpui2::test]
#[gpui::test]
fn test_language_scope_at_with_rust(cx: &mut AppContext) {
init_settings(cx, |_| {});
@ -1806,7 +1806,7 @@ fn test_language_scope_at_with_rust(cx: &mut AppContext) {
});
}
#[gpui2::test]
#[gpui::test]
fn test_language_scope_at_with_combined_injections(cx: &mut AppContext) {
init_settings(cx, |_| {});
@ -1854,8 +1854,8 @@ fn test_language_scope_at_with_combined_injections(cx: &mut AppContext) {
});
}
#[gpui2::test]
fn test_serialization(cx: &mut gpui2::AppContext) {
#[gpui::test]
fn test_serialization(cx: &mut gpui::AppContext) {
let mut now = Instant::now();
let buffer1 = cx.build_model(|cx| {
@ -1895,7 +1895,7 @@ fn test_serialization(cx: &mut gpui2::AppContext) {
assert_eq!(buffer2.read(cx).text(), "abcDF");
}
#[gpui2::test(iterations = 100)]
#[gpui::test(iterations = 100)]
fn test_random_collaboration(cx: &mut AppContext, mut rng: StdRng) {
let min_peers = env::var("MIN_PEERS")
.map(|i| i.parse().expect("invalid `MIN_PEERS` variable"))
@ -2199,7 +2199,7 @@ fn test_contiguous_ranges() {
);
}
#[gpui2::test(iterations = 500)]
#[gpui::test(iterations = 500)]
fn test_trailing_whitespace_ranges(mut rng: StdRng) {
// Generate a random multi-line string containing
// some lines with trailing whitespace.
@ -2400,7 +2400,7 @@ fn javascript_lang() -> Language {
.unwrap()
}
fn get_tree_sexp(buffer: &Model<Buffer>, cx: &mut gpui2::TestAppContext) -> String {
fn get_tree_sexp(buffer: &Model<Buffer>, cx: &mut gpui::TestAppContext) -> String {
buffer.update(cx, |buffer, _| {
let snapshot = buffer.snapshot();
let layers = snapshot.syntax.layers(buffer.as_text_snapshot());

8
crates/language2/src/diagnostic_set.rs
View File

@ -1,6 +1,6 @@
use crate::Diagnostic;
use collections::HashMap;
use lsp2::LanguageServerId;
use lsp::LanguageServerId;
use std::{
cmp::{Ordering, Reverse},
iter,
@ -37,14 +37,14 @@ pub struct Summary {
impl<T> DiagnosticEntry<T> {
// Used to provide diagnostic context to lsp codeAction request
pub fn to_lsp_diagnostic_stub(&self) -> lsp2::Diagnostic {
pub fn to_lsp_diagnostic_stub(&self) -> lsp::Diagnostic {
let code = self
.diagnostic
.code
.clone()
.map(lsp2::NumberOrString::String);
.map(lsp::NumberOrString::String);
lsp2::Diagnostic {
lsp::Diagnostic {
code,
severity: Some(self.diagnostic.severity),
..Default::default()

6
crates/language2/src/highlight_map.rs
View File

@ -1,6 +1,6 @@
use gpui2::HighlightStyle;
use gpui::HighlightStyle;
use std::sync::Arc;
use theme2::SyntaxTheme;
use theme::SyntaxTheme;
#[derive(Clone, Debug)]
pub struct HighlightMap(Arc<[HighlightId]>);
@ -79,7 +79,7 @@ impl Default for HighlightId {
#[cfg(test)]
mod tests {
use super::*;
use gpui2::rgba;
use gpui::rgba;
#[test]
fn test_highlight_map() {

70
crates/language2/src/language2.rs
View File

@ -17,10 +17,10 @@ use futures::{
future::{BoxFuture, Shared},
FutureExt, TryFutureExt as _,
};
use gpui2::{AppContext, AsyncAppContext, BackgroundExecutor, Task};
use gpui::{AppContext, AsyncAppContext, BackgroundExecutor, Task};
pub use highlight_map::HighlightMap;
use lazy_static::lazy_static;
use lsp2::{CodeActionKind, LanguageServerBinary};
use lsp::{CodeActionKind, LanguageServerBinary};
use parking_lot::{Mutex, RwLock};
use postage::watch;
use regex::Regex;
@ -42,7 +42,7 @@ use std::{
},
};
use syntax_map::SyntaxSnapshot;
use theme2::{SyntaxTheme, ThemeVariant};
use theme::{SyntaxTheme, ThemeVariant};
use tree_sitter::{self, Query};
use unicase::UniCase;
use util::{http::HttpClient, paths::PathExt};
@ -51,7 +51,7 @@ use util::{post_inc, ResultExt, TryFutureExt as _, UnwrapFuture};
pub use buffer::Operation;
pub use buffer::*;
pub use diagnostic_set::DiagnosticEntry;
pub use lsp2::LanguageServerId;
pub use lsp::LanguageServerId;
pub use outline::{Outline, OutlineItem};
pub use syntax_map::{OwnedSyntaxLayerInfo, SyntaxLayerInfo};
pub use text::LineEnding;
@ -98,7 +98,7 @@ lazy_static! {
}
pub trait ToLspPosition {
fn to_lsp_position(self) -> lsp2::Position;
fn to_lsp_position(self) -> lsp::Position;
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
@ -203,17 +203,17 @@ impl CachedLspAdapter {
self.adapter.workspace_configuration(cx)
}
pub fn process_diagnostics(&self, params: &mut lsp2::PublishDiagnosticsParams) {
pub fn process_diagnostics(&self, params: &mut lsp::PublishDiagnosticsParams) {
self.adapter.process_diagnostics(params)
}
pub async fn process_completion(&self, completion_item: &mut lsp2::CompletionItem) {
pub async fn process_completion(&self, completion_item: &mut lsp::CompletionItem) {
self.adapter.process_completion(completion_item).await
}
pub async fn label_for_completion(
&self,
completion_item: &lsp2::CompletionItem,
completion_item: &lsp::CompletionItem,
language: &Arc<Language>,
) -> Option<CodeLabel> {
self.adapter
@ -224,7 +224,7 @@ impl CachedLspAdapter {
pub async fn label_for_symbol(
&self,
name: &str,
kind: lsp2::SymbolKind,
kind: lsp::SymbolKind,
language: &Arc<Language>,
) -> Option<CodeLabel> {
self.adapter.label_for_symbol(name, kind, language).await
@ -289,13 +289,13 @@ pub trait LspAdapter: 'static + Send + Sync {
container_dir: PathBuf,
) -> Option<LanguageServerBinary>;
fn process_diagnostics(&self, _: &mut lsp2::PublishDiagnosticsParams) {}
fn process_diagnostics(&self, _: &mut lsp::PublishDiagnosticsParams) {}
async fn process_completion(&self, _: &mut lsp2::CompletionItem) {}
async fn process_completion(&self, _: &mut lsp::CompletionItem) {}
async fn label_for_completion(
&self,
_: &lsp2::CompletionItem,
_: &lsp::CompletionItem,
_: &Arc<Language>,
) -> Option<CodeLabel> {
None
@ -304,7 +304,7 @@ pub trait LspAdapter: 'static + Send + Sync {
async fn label_for_symbol(
&self,
_: &str,
_: lsp2::SymbolKind,
_: lsp::SymbolKind,
_: &Arc<Language>,
) -> Option<CodeLabel> {
None
@ -476,8 +476,8 @@ fn deserialize_regex<'de, D: Deserializer<'de>>(d: D) -> Result<Option<Regex>, D
pub struct FakeLspAdapter {
pub name: &'static str,
pub initialization_options: Option<Value>,
pub capabilities: lsp2::ServerCapabilities,
pub initializer: Option<Box<dyn 'static + Send + Sync + Fn(&mut lsp2::FakeLanguageServer)>>,
pub capabilities: lsp::ServerCapabilities,
pub initializer: Option<Box<dyn 'static + Send + Sync + Fn(&mut lsp::FakeLanguageServer)>>,
pub disk_based_diagnostics_progress_token: Option<String>,
pub disk_based_diagnostics_sources: Vec<String>,
pub prettier_plugins: Vec<&'static str>,
@ -532,7 +532,7 @@ pub struct Language {
#[cfg(any(test, feature = "test-support"))]
fake_adapter: Option<(
mpsc::UnboundedSender<lsp2::FakeLanguageServer>,
mpsc::UnboundedSender<lsp::FakeLanguageServer>,
Arc<FakeLspAdapter>,
)>,
}
@ -649,7 +649,7 @@ struct LanguageRegistryState {
pub struct PendingLanguageServer {
pub server_id: LanguageServerId,
pub task: Task<Result<lsp2::LanguageServer>>,
pub task: Task<Result<lsp::LanguageServer>>,
pub container_dir: Option<Arc<Path>>,
}
@ -905,7 +905,7 @@ impl LanguageRegistry {
if language.fake_adapter.is_some() {
let task = cx.spawn(|cx| async move {
let (servers_tx, fake_adapter) = language.fake_adapter.as_ref().unwrap();
let (server, mut fake_server) = lsp2::LanguageServer::fake(
let (server, mut fake_server) = lsp::LanguageServer::fake(
fake_adapter.name.to_string(),
fake_adapter.capabilities.clone(),
cx.clone(),
@ -919,7 +919,7 @@ impl LanguageRegistry {
cx.background_executor()
.spawn(async move {
if fake_server
.try_receive_notification::<lsp2::notification::Initialized>()
.try_receive_notification::<lsp::notification::Initialized>()
.await
.is_some()
{
@ -988,7 +988,7 @@ impl LanguageRegistry {
task.await?;
}
lsp2::LanguageServer::new(
lsp::LanguageServer::new(
stderr_capture,
server_id,
binary,
@ -1471,7 +1471,7 @@ impl Language {
pub async fn set_fake_lsp_adapter(
&mut self,
fake_lsp_adapter: Arc<FakeLspAdapter>,
) -> mpsc::UnboundedReceiver<lsp2::FakeLanguageServer> {
) -> mpsc::UnboundedReceiver<lsp::FakeLanguageServer> {
let (servers_tx, servers_rx) = mpsc::unbounded();
self.fake_adapter = Some((servers_tx, fake_lsp_adapter.clone()));
let adapter = CachedLspAdapter::new(Arc::new(fake_lsp_adapter)).await;
@ -1501,7 +1501,7 @@ impl Language {
None
}
pub async fn process_completion(self: &Arc<Self>, completion: &mut lsp2::CompletionItem) {
pub async fn process_completion(self: &Arc<Self>, completion: &mut lsp::CompletionItem) {
for adapter in &self.adapters {
adapter.process_completion(completion).await;
}
@ -1509,7 +1509,7 @@ impl Language {
pub async fn label_for_completion(
self: &Arc<Self>,
completion: &lsp2::CompletionItem,
completion: &lsp::CompletionItem,
) -> Option<CodeLabel> {
self.adapters
.first()
@ -1521,7 +1521,7 @@ impl Language {
pub async fn label_for_symbol(
self: &Arc<Self>,
name: &str,
kind: lsp2::SymbolKind,
kind: lsp::SymbolKind,
) -> Option<CodeLabel> {
self.adapters
.first()
@ -1745,7 +1745,7 @@ impl Default for FakeLspAdapter {
fn default() -> Self {
Self {
name: "the-fake-language-server",
capabilities: lsp2::LanguageServer::full_capabilities(),
capabilities: lsp::LanguageServer::full_capabilities(),
initializer: None,
disk_based_diagnostics_progress_token: None,
initialization_options: None,
@ -1794,7 +1794,7 @@ impl LspAdapter for Arc<FakeLspAdapter> {
unreachable!();
}
fn process_diagnostics(&self, _: &mut lsp2::PublishDiagnosticsParams) {}
fn process_diagnostics(&self, _: &mut lsp::PublishDiagnosticsParams) {}
async fn disk_based_diagnostic_sources(&self) -> Vec<String> {
self.disk_based_diagnostics_sources.clone()
@ -1824,22 +1824,22 @@ fn get_capture_indices(query: &Query, captures: &mut [(&str, &mut Option<u32>)])
}
}
pub fn point_to_lsp(point: PointUtf16) -> lsp2::Position {
lsp2::Position::new(point.row, point.column)
pub fn point_to_lsp(point: PointUtf16) -> lsp::Position {
lsp::Position::new(point.row, point.column)
}
pub fn point_from_lsp(point: lsp2::Position) -> Unclipped<PointUtf16> {
pub fn point_from_lsp(point: lsp::Position) -> Unclipped<PointUtf16> {
Unclipped(PointUtf16::new(point.line, point.character))
}
pub fn range_to_lsp(range: Range<PointUtf16>) -> lsp2::Range {
lsp2::Range {
pub fn range_to_lsp(range: Range<PointUtf16>) -> lsp::Range {
lsp::Range {
start: point_to_lsp(range.start),
end: point_to_lsp(range.end),
}
}
pub fn range_from_lsp(range: lsp2::Range) -> Range<Unclipped<PointUtf16>> {
pub fn range_from_lsp(range: lsp::Range) -> Range<Unclipped<PointUtf16>> {
let mut start = point_from_lsp(range.start);
let mut end = point_from_lsp(range.end);
if start > end {
@ -1851,9 +1851,9 @@ pub fn range_from_lsp(range: lsp2::Range) -> Range<Unclipped<PointUtf16>> {
#[cfg(test)]
mod tests {
use super::*;
use gpui2::TestAppContext;
use gpui::TestAppContext;
#[gpui2::test(iterations = 10)]
#[gpui::test(iterations = 10)]
async fn test_first_line_pattern(cx: &mut TestAppContext) {
let mut languages = LanguageRegistry::test();
@ -1891,7 +1891,7 @@ mod tests {
);
}
#[gpui2::test(iterations = 10)]
#[gpui::test(iterations = 10)]
async fn test_language_loading(cx: &mut TestAppContext) {
let mut languages = LanguageRegistry::test();
languages.set_executor(cx.executor().clone());

8
crates/language2/src/language_settings.rs
View File

@ -2,13 +2,13 @@ use crate::{File, Language};
use anyhow::Result;
use collections::{HashMap, HashSet};
use globset::GlobMatcher;
use gpui2::AppContext;
use gpui::AppContext;
use schemars::{
schema::{InstanceType, ObjectValidation, Schema, SchemaObject},
JsonSchema,
};
use serde::{Deserialize, Serialize};
use settings2::Settings;
use settings::Settings;
use std::{num::NonZeroU32, path::Path, sync::Arc};
pub fn init(cx: &mut AppContext) {
@ -255,7 +255,7 @@ impl InlayHintKind {
}
}
impl settings2::Settings for AllLanguageSettings {
impl settings::Settings for AllLanguageSettings {
const KEY: Option<&'static str> = None;
type FileContent = AllLanguageSettingsContent;
@ -332,7 +332,7 @@ impl settings2::Settings for AllLanguageSettings {
fn json_schema(
generator: &mut schemars::gen::SchemaGenerator,
params: &settings2::SettingsJsonSchemaParams,
params: &settings::SettingsJsonSchemaParams,
_: &AppContext,
) -> schemars::schema::RootSchema {
let mut root_schema = generator.root_schema_for::<Self::FileContent>();

6
crates/language2/src/outline.rs
View File

@ -1,5 +1,5 @@
use fuzzy2::{StringMatch, StringMatchCandidate};
use gpui2::{BackgroundExecutor, HighlightStyle};
use fuzzy::{StringMatch, StringMatchCandidate};
use gpui::{BackgroundExecutor, HighlightStyle};
use std::ops::Range;
#[derive(Debug)]
@ -61,7 +61,7 @@ impl<T> Outline<T> {
let query = query.trim_start();
let is_path_query = query.contains(' ');
let smart_case = query.chars().any(|c| c.is_uppercase());
let mut matches = fuzzy2::match_strings(
let mut matches = fuzzy::match_strings(
if is_path_query {
&self.path_candidates
} else {

4
crates/language2/src/proto.rs
View File

@ -4,8 +4,8 @@ use crate::{
};
use anyhow::{anyhow, Result};
use clock::ReplicaId;
use lsp2::{DiagnosticSeverity, LanguageServerId};
use rpc2::proto;
use lsp::{DiagnosticSeverity, LanguageServerId};
use rpc::proto;
use std::{ops::Range, sync::Arc};
use text::*;

42
crates/language2/src/syntax_map/syntax_map_tests.rs
View File

@ -78,7 +78,7 @@ fn test_splice_included_ranges() {
}
}
#[gpui2::test]
#[gpui::test]
fn test_syntax_map_layers_for_range() {
let registry = Arc::new(LanguageRegistry::test());
let language = Arc::new(rust_lang());
@ -175,7 +175,7 @@ fn test_syntax_map_layers_for_range() {
);
}
#[gpui2::test]
#[gpui::test]
fn test_dynamic_language_injection() {
let registry = Arc::new(LanguageRegistry::test());
let markdown = Arc::new(markdown_lang());
@ -253,7 +253,7 @@ fn test_dynamic_language_injection() {
assert!(!syntax_map.contains_unknown_injections());
}
#[gpui2::test]
#[gpui::test]
fn test_typing_multiple_new_injections() {
let (buffer, syntax_map) = test_edit_sequence(
"Rust",
@ -282,7 +282,7 @@ fn test_typing_multiple_new_injections() {
);
}
#[gpui2::test]
#[gpui::test]
fn test_pasting_new_injection_line_between_others() {
let (buffer, syntax_map) = test_edit_sequence(
"Rust",
@ -329,7 +329,7 @@ fn test_pasting_new_injection_line_between_others() {
);
}
#[gpui2::test]
#[gpui::test]
fn test_joining_injections_with_child_injections() {
let (buffer, syntax_map) = test_edit_sequence(
"Rust",
@ -373,7 +373,7 @@ fn test_joining_injections_with_child_injections() {
);
}
#[gpui2::test]
#[gpui::test]
fn test_editing_edges_of_injection() {
test_edit_sequence(
"Rust",
@ -402,7 +402,7 @@ fn test_editing_edges_of_injection() {
);
}
#[gpui2::test]
#[gpui::test]
fn test_edits_preceding_and_intersecting_injection() {
test_edit_sequence(
"Rust",
@ -414,7 +414,7 @@ fn test_edits_preceding_and_intersecting_injection() {
);
}
#[gpui2::test]
#[gpui::test]
fn test_non_local_changes_create_injections() {
test_edit_sequence(
"Rust",
@ -433,7 +433,7 @@ fn test_non_local_changes_create_injections() {
);
}
#[gpui2::test]
#[gpui::test]
fn test_creating_many_injections_in_one_edit() {
test_edit_sequence(
"Rust",
@ -463,7 +463,7 @@ fn test_creating_many_injections_in_one_edit() {
);
}
#[gpui2::test]
#[gpui::test]
fn test_editing_across_injection_boundary() {
test_edit_sequence(
"Rust",
@ -491,7 +491,7 @@ fn test_editing_across_injection_boundary() {
);
}
#[gpui2::test]
#[gpui::test]
fn test_removing_injection_by_replacing_across_boundary() {
test_edit_sequence(
"Rust",
@ -517,7 +517,7 @@ fn test_removing_injection_by_replacing_across_boundary() {
);
}
#[gpui2::test]
#[gpui::test]
fn test_combined_injections_simple() {
let (buffer, syntax_map) = test_edit_sequence(
"ERB",
@ -564,7 +564,7 @@ fn test_combined_injections_simple() {
);
}
#[gpui2::test]
#[gpui::test]
fn test_combined_injections_empty_ranges() {
test_edit_sequence(
"ERB",
@ -582,7 +582,7 @@ fn test_combined_injections_empty_ranges() {
);
}
#[gpui2::test]
#[gpui::test]
fn test_combined_injections_edit_edges_of_ranges() {
let (buffer, syntax_map) = test_edit_sequence(
"ERB",
@ -613,7 +613,7 @@ fn test_combined_injections_edit_edges_of_ranges() {
);
}
#[gpui2::test]
#[gpui::test]
fn test_combined_injections_splitting_some_injections() {
let (_buffer, _syntax_map) = test_edit_sequence(
"ERB",
@ -638,7 +638,7 @@ fn test_combined_injections_splitting_some_injections() {
);
}
#[gpui2::test]
#[gpui::test]
fn test_combined_injections_editing_after_last_injection() {
test_edit_sequence(
"ERB",
@ -658,7 +658,7 @@ fn test_combined_injections_editing_after_last_injection() {
);
}
#[gpui2::test]
#[gpui::test]
fn test_combined_injections_inside_injections() {
let (buffer, syntax_map) = test_edit_sequence(
"Markdown",
@ -734,7 +734,7 @@ fn test_combined_injections_inside_injections() {
);
}
#[gpui2::test]
#[gpui::test]
fn test_empty_combined_injections_inside_injections() {
let (buffer, syntax_map) = test_edit_sequence(
"Markdown",
@ -762,7 +762,7 @@ fn test_empty_combined_injections_inside_injections() {
);
}
#[gpui2::test(iterations = 50)]
#[gpui::test(iterations = 50)]
fn test_random_syntax_map_edits_rust_macros(rng: StdRng) {
let text = r#"
fn test_something() {
@ -788,7 +788,7 @@ fn test_random_syntax_map_edits_rust_macros(rng: StdRng) {
test_random_edits(text, registry, language, rng);
}
#[gpui2::test(iterations = 50)]
#[gpui::test(iterations = 50)]
fn test_random_syntax_map_edits_with_erb(rng: StdRng) {
let text = r#"
<div id="main">
@ -817,7 +817,7 @@ fn test_random_syntax_map_edits_with_erb(rng: StdRng) {
test_random_edits(text, registry, language, rng);
}
#[gpui2::test(iterations = 50)]
#[gpui::test(iterations = 50)]
fn test_random_syntax_map_edits_with_heex(rng: StdRng) {
let text = r#"
defmodule TheModule do

4
crates/live_kit_client2/Cargo.toml
View File

@ -23,7 +23,7 @@ test-support = [
[dependencies]
collections = { path = "../collections", optional = true }
gpui2 = { path = "../gpui2", optional = true }
gpui2 = { package = "gpui2", path = "../gpui2", optional = true }
live_kit_server = { path = "../live_kit_server", optional = true }
media = { path = "../media" }
@ -41,7 +41,7 @@ nanoid = { version ="0.4", optional = true}
[dev-dependencies]
collections = { path = "../collections", features = ["test-support"] }
gpui2 = { path = "../gpui2", features = ["test-support"] }
gpui2 = { package = "gpui2", path = "../gpui2", features = ["test-support"] }
live_kit_server = { path = "../live_kit_server" }
media = { path = "../media" }
nanoid = "0.4"

4
crates/lsp2/Cargo.toml
View File

@ -13,7 +13,7 @@ test-support = ["async-pipe"]
[dependencies]
collections = { path = "../collections" }
gpui2 = { path = "../gpui2" }
gpui = { package = "gpui2", path = "../gpui2" }
util = { path = "../util" }
anyhow.workspace = true
@ -29,7 +29,7 @@ serde_json.workspace = true
smol.workspace = true
[dev-dependencies]
gpui2 = { path = "../gpui2", features = ["test-support"] }
gpui = { package = "gpui2", path = "../gpui2", features = ["test-support"] }
util = { path = "../util", features = ["test-support"] }
async-pipe = { git = "https://github.com/zed-industries/async-pipe-rs", rev = "82d00a04211cf4e1236029aa03e6b6ce2a74c553" }

10
crates/lsp2/src/lsp2.rs
View File

@ -5,7 +5,7 @@ pub use lsp_types::*;
use anyhow::{anyhow, Context, Result};
use collections::HashMap;
use futures::{channel::oneshot, io::BufWriter, AsyncRead, AsyncWrite, FutureExt};
use gpui2::{AsyncAppContext, BackgroundExecutor, Task};
use gpui::{AsyncAppContext, BackgroundExecutor, Task};
use parking_lot::Mutex;
use postage::{barrier, prelude::Stream};
use serde::{de::DeserializeOwned, Deserialize, Serialize};
@ -1038,7 +1038,7 @@ impl FakeLanguageServer {
where
T: 'static + request::Request,
T::Params: 'static + Send,
F: 'static + Send + FnMut(T::Params, gpui2::AsyncAppContext) -> Fut,
F: 'static + Send + FnMut(T::Params, gpui::AsyncAppContext) -> Fut,
Fut: 'static + Send + Future<Output = Result<T::Result>>,
{
let (responded_tx, responded_rx) = futures::channel::mpsc::unbounded();
@ -1066,7 +1066,7 @@ impl FakeLanguageServer {
where
T: 'static + notification::Notification,
T::Params: 'static + Send,
F: 'static + Send + FnMut(T::Params, gpui2::AsyncAppContext),
F: 'static + Send + FnMut(T::Params, gpui::AsyncAppContext),
{
let (handled_tx, handled_rx) = futures::channel::mpsc::unbounded();
self.server.remove_notification_handler::<T>();
@ -1110,7 +1110,7 @@ impl FakeLanguageServer {
#[cfg(test)]
mod tests {
use super::*;
use gpui2::TestAppContext;
use gpui::TestAppContext;
#[ctor::ctor]
fn init_logger() {
@ -1119,7 +1119,7 @@ mod tests {
}
}
#[gpui2::test]
#[gpui::test]
async fn test_fake(cx: &mut TestAppContext) {
let (server, mut fake) =
LanguageServer::fake("the-lsp".to_string(), Default::default(), cx.to_async());

2
crates/menu2/Cargo.toml
View File

@ -9,4 +9,4 @@ path = "src/menu2.rs"
doctest = false
[dependencies]
gpui2 = { path = "../gpui2" }
gpui = { package = "gpui2", path = "../gpui2" }

30
crates/multi_buffer2/Cargo.toml
View File

@ -10,29 +10,29 @@ doctest = false
[features]
test-support = [
"copilot2/test-support",
"copilot/test-support",
"text/test-support",
"language2/test-support",
"gpui2/test-support",
"language/test-support",
"gpui/test-support",
"util/test-support",
"tree-sitter-rust",
"tree-sitter-typescript"
]
[dependencies]
client2 = { path = "../client2" }
client = { package = "client2", path = "../client2" }
clock = { path = "../clock" }
collections = { path = "../collections" }
git = { path = "../git" }
gpui2 = { path = "../gpui2" }
language2 = { path = "../language2" }
lsp2 = { path = "../lsp2" }
gpui = { package = "gpui2", path = "../gpui2" }
language = { package = "language2", path = "../language2" }
lsp = { package = "lsp2", path = "../lsp2" }
rich_text = { path = "../rich_text" }
settings2 = { path = "../settings2" }
settings = { package = "settings2", path = "../settings2" }
snippet = { path = "../snippet" }
sum_tree = { path = "../sum_tree" }
text = { path = "../text" }
theme2 = { path = "../theme2" }
theme = { package = "theme2", path = "../theme2" }
util = { path = "../util" }
aho-corasick = "1.1"
@ -59,14 +59,14 @@ tree-sitter-html = { workspace = true, optional = true }
tree-sitter-typescript = { workspace = true, optional = true }
[dev-dependencies]
copilot2 = { path = "../copilot2", features = ["test-support"] }
copilot = { package = "copilot2", path = "../copilot2", features = ["test-support"] }
text = { path = "../text", features = ["test-support"] }
language2 = { path = "../language2", features = ["test-support"] }
lsp2 = { path = "../lsp2", features = ["test-support"] }
gpui2 = { path = "../gpui2", features = ["test-support"] }
language = { package = "language2", path = "../language2", features = ["test-support"] }
lsp = { package = "lsp2", path = "../lsp2", features = ["test-support"] }
gpui = { package = "gpui2", path = "../gpui2", features = ["test-support"] }
util = { path = "../util", features = ["test-support"] }
project2 = { path = "../project2", features = ["test-support"] }
settings2 = { path = "../settings2", features = ["test-support"] }
project = { package = "project2", path = "../project2", features = ["test-support"] }
settings = { package = "settings2", path = "../settings2", features = ["test-support"] }
ctor.workspace = true
env_logger.workspace = true

2
crates/multi_buffer2/src/anchor.rs
View File

@ -1,5 +1,5 @@
use super::{ExcerptId, MultiBufferSnapshot, ToOffset, ToOffsetUtf16, ToPoint};
use language2::{OffsetUtf16, Point, TextDimension};
use language::{OffsetUtf16, Point, TextDimension};
use std::{
cmp::Ordering,
ops::{Range, Sub},

84
crates/multi_buffer2/src/multi_buffer2.rs
View File

@ -6,9 +6,9 @@ use clock::ReplicaId;
use collections::{BTreeMap, Bound, HashMap, HashSet};
use futures::{channel::mpsc, SinkExt};
use git::diff::DiffHunk;
use gpui2::{AppContext, EventEmitter, Model, ModelContext};
pub use language2::Completion;
use language2::{
use gpui::{AppContext, EventEmitter, Model, ModelContext};
pub use language::Completion;
use language::{
char_kind,
language_settings::{language_settings, LanguageSettings},
AutoindentMode, Buffer, BufferChunks, BufferSnapshot, CharKind, Chunk, CursorShape,
@ -35,11 +35,11 @@ use text::{
subscription::{Subscription, Topic},
Edit, TextSummary,
};
use theme2::SyntaxTheme;
use theme::SyntaxTheme;
use util::post_inc;
#[cfg(any(test, feature = "test-support"))]
use gpui2::Context;
use gpui::Context;
const NEWLINES: &[u8] = &[b'\n'; u8::MAX as usize];
@ -62,7 +62,7 @@ pub enum Event {
ExcerptsAdded {
buffer: Model<Buffer>,
predecessor: ExcerptId,
excerpts: Vec<(ExcerptId, ExcerptRange<language2::Anchor>)>,
excerpts: Vec<(ExcerptId, ExcerptRange<language::Anchor>)>,
},
ExcerptsRemoved {
ids: Vec<ExcerptId>,
@ -130,7 +130,7 @@ struct BufferState {
last_file_update_count: usize,
last_git_diff_update_count: usize,
excerpts: Vec<Locator>,
_subscriptions: [gpui2::Subscription; 2],
_subscriptions: [gpui::Subscription; 2],
}
#[derive(Clone, Default)]
@ -684,7 +684,7 @@ impl MultiBuffer {
pub fn push_transaction<'a, T>(&mut self, buffer_transactions: T, cx: &mut ModelContext<Self>)
where
T: IntoIterator<Item = (&'a Model<Buffer>, &'a language2::Transaction)>,
T: IntoIterator<Item = (&'a Model<Buffer>, &'a language::Transaction)>,
{
self.history
.push_transaction(buffer_transactions, Instant::now(), cx);
@ -1383,7 +1383,7 @@ impl MultiBuffer {
&self,
position: T,
cx: &AppContext,
) -> Option<(Model<Buffer>, language2::Anchor)> {
) -> Option<(Model<Buffer>, language::Anchor)> {
let snapshot = self.read(cx);
let anchor = snapshot.anchor_before(position);
let buffer = self
@ -1398,25 +1398,25 @@ impl MultiBuffer {
fn on_buffer_event(
&mut self,
_: Model<Buffer>,
event: &language2::Event,
event: &language::Event,
cx: &mut ModelContext<Self>,
) {
cx.emit(match event {
language2::Event::Edited => Event::Edited {
language::Event::Edited => Event::Edited {
sigleton_buffer_edited: true,
},
language2::Event::DirtyChanged => Event::DirtyChanged,
language2::Event::Saved => Event::Saved,
language2::Event::FileHandleChanged => Event::FileHandleChanged,
language2::Event::Reloaded => Event::Reloaded,
language2::Event::DiffBaseChanged => Event::DiffBaseChanged,
language2::Event::LanguageChanged => Event::LanguageChanged,
language2::Event::Reparsed => Event::Reparsed,
language2::Event::DiagnosticsUpdated => Event::DiagnosticsUpdated,
language2::Event::Closed => Event::Closed,
language::Event::DirtyChanged => Event::DirtyChanged,
language::Event::Saved => Event::Saved,
language::Event::FileHandleChanged => Event::FileHandleChanged,
language::Event::Reloaded => Event::Reloaded,
language::Event::DiffBaseChanged => Event::DiffBaseChanged,
language::Event::LanguageChanged => Event::LanguageChanged,
language::Event::Reparsed => Event::Reparsed,
language::Event::DiagnosticsUpdated => Event::DiagnosticsUpdated,
language::Event::Closed => Event::Closed,
//
language2::Event::Operation(_) => return,
language::Event::Operation(_) => return,
});
}
@ -1648,14 +1648,14 @@ impl MultiBuffer {
#[cfg(any(test, feature = "test-support"))]
impl MultiBuffer {
pub fn build_simple(text: &str, cx: &mut gpui2::AppContext) -> Model<Self> {
pub fn build_simple(text: &str, cx: &mut gpui::AppContext) -> Model<Self> {
let buffer = cx.build_model(|cx| Buffer::new(0, cx.entity_id().as_u64(), text));
cx.build_model(|cx| Self::singleton(buffer, cx))
}
pub fn build_multi<const COUNT: usize>(
excerpts: [(&str, Vec<Range<Point>>); COUNT],
cx: &mut gpui2::AppContext,
cx: &mut gpui::AppContext,
) -> Model<Self> {
let multi = cx.build_model(|_| Self::new(0));
for (text, ranges) in excerpts {
@ -1672,11 +1672,11 @@ impl MultiBuffer {
multi
}
pub fn build_from_buffer(buffer: Model<Buffer>, cx: &mut gpui2::AppContext) -> Model<Self> {
pub fn build_from_buffer(buffer: Model<Buffer>, cx: &mut gpui::AppContext) -> Model<Self> {
cx.build_model(|cx| Self::singleton(buffer, cx))
}
pub fn build_random(rng: &mut impl rand::Rng, cx: &mut gpui2::AppContext) -> Model<Self> {
pub fn build_random(rng: &mut impl rand::Rng, cx: &mut gpui::AppContext) -> Model<Self> {
cx.build_model(|cx| {
let mut multibuffer = MultiBuffer::new(0);
let mutation_count = rng.gen_range(1..=5);
@ -3409,7 +3409,7 @@ impl History {
now: Instant,
cx: &mut ModelContext<MultiBuffer>,
) where
T: IntoIterator<Item = (&'a Model<Buffer>, &'a language2::Transaction)>,
T: IntoIterator<Item = (&'a Model<Buffer>, &'a language::Transaction)>,
{
assert_eq!(self.transaction_depth, 0);
let transaction = Transaction {
@ -4135,15 +4135,15 @@ where
mod tests {
use super::*;
use futures::StreamExt;
use gpui2::{AppContext, Context, TestAppContext};
use language2::{Buffer, Rope};
use gpui::{AppContext, Context, TestAppContext};
use language::{Buffer, Rope};
use parking_lot::RwLock;
use rand::prelude::*;
use settings2::SettingsStore;
use settings::SettingsStore;
use std::env;
use util::test::sample_text;
#[gpui2::test]
#[gpui::test]
fn test_singleton(cx: &mut AppContext) {
let buffer =
cx.build_model(|cx| Buffer::new(0, cx.entity_id().as_u64(), sample_text(6, 6, 'a')));
@ -4171,7 +4171,7 @@ mod tests {
);
}
#[gpui2::test]
#[gpui::test]
fn test_remote(cx: &mut AppContext) {
let host_buffer = cx.build_model(|cx| Buffer::new(0, cx.entity_id().as_u64(), "a"));
let guest_buffer = cx.build_model(|cx| {
@ -4183,7 +4183,7 @@ mod tests {
buffer
.apply_ops(
ops.into_iter()
.map(|op| language2::proto::deserialize_operation(op).unwrap()),
.map(|op| language::proto::deserialize_operation(op).unwrap()),
cx,
)
.unwrap();
@ -4202,7 +4202,7 @@ mod tests {
assert_eq!(snapshot.text(), "abc");
}
#[gpui2::test]
#[gpui::test]
fn test_excerpt_boundaries_and_clipping(cx: &mut AppContext) {
let buffer_1 =
cx.build_model(|cx| Buffer::new(0, cx.entity_id().as_u64(), sample_text(6, 6, 'a')));
@ -4438,7 +4438,7 @@ mod tests {
}
}
#[gpui2::test]
#[gpui::test]
fn test_excerpt_events(cx: &mut AppContext) {
let buffer_1 =
cx.build_model(|cx| Buffer::new(0, cx.entity_id().as_u64(), sample_text(10, 3, 'a')));
@ -4546,7 +4546,7 @@ mod tests {
assert_eq!(*follower_edit_event_count.read(), 4);
}
#[gpui2::test]
#[gpui::test]
fn test_push_excerpts_with_context_lines(cx: &mut AppContext) {
let buffer =
cx.build_model(|cx| Buffer::new(0, cx.entity_id().as_u64(), sample_text(20, 3, 'a')));
@ -4583,7 +4583,7 @@ mod tests {
);
}
#[gpui2::test]
#[gpui::test]
async fn test_stream_excerpts_with_context_lines(cx: &mut TestAppContext) {
let buffer =
cx.build_model(|cx| Buffer::new(0, cx.entity_id().as_u64(), sample_text(20, 3, 'a')));
@ -4620,7 +4620,7 @@ mod tests {
);
}
#[gpui2::test]
#[gpui::test]
fn test_empty_multibuffer(cx: &mut AppContext) {
let multibuffer = cx.build_model(|_| MultiBuffer::new(0));
@ -4630,7 +4630,7 @@ mod tests {
assert_eq!(snapshot.buffer_rows(1).collect::<Vec<_>>(), &[]);
}
#[gpui2::test]
#[gpui::test]
fn test_singleton_multibuffer_anchors(cx: &mut AppContext) {
let buffer = cx.build_model(|cx| Buffer::new(0, cx.entity_id().as_u64(), "abcd"));
let multibuffer = cx.build_model(|cx| MultiBuffer::singleton(buffer.clone(), cx));
@ -4650,7 +4650,7 @@ mod tests {
assert_eq!(old_snapshot.anchor_after(4).to_offset(&new_snapshot), 6);
}
#[gpui2::test]
#[gpui::test]
fn test_multibuffer_anchors(cx: &mut AppContext) {
let buffer_1 = cx.build_model(|cx| Buffer::new(0, cx.entity_id().as_u64(), "abcd"));
let buffer_2 = cx.build_model(|cx| Buffer::new(0, cx.entity_id().as_u64(), "efghi"));
@ -4708,7 +4708,7 @@ mod tests {
assert_eq!(old_snapshot.anchor_after(10).to_offset(&new_snapshot), 14);
}
#[gpui2::test]
#[gpui::test]
fn test_resolving_anchors_after_replacing_their_excerpts(cx: &mut AppContext) {
let buffer_1 = cx.build_model(|cx| Buffer::new(0, cx.entity_id().as_u64(), "abcd"));
let buffer_2 =
@ -4840,7 +4840,7 @@ mod tests {
);
}
#[gpui2::test(iterations = 100)]
#[gpui::test(iterations = 100)]
fn test_random_multibuffer(cx: &mut AppContext, mut rng: StdRng) {
let operations = env::var("OPERATIONS")
.map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
@ -5262,7 +5262,7 @@ mod tests {
}
}
#[gpui2::test]
#[gpui::test]
fn test_history(cx: &mut AppContext) {
let test_settings = SettingsStore::test(cx);
cx.set_global(test_settings);

16
crates/prettier2/Cargo.toml
View File

@ -12,12 +12,12 @@ doctest = false
test-support = []
[dependencies]
client2 = { path = "../client2" }
client = { package = "client2", path = "../client2" }
collections = { path = "../collections"}
language2 = { path = "../language2" }
gpui2 = { path = "../gpui2" }
fs2 = { path = "../fs2" }
lsp2 = { path = "../lsp2" }
language = { package = "language2", path = "../language2" }
gpui = { package = "gpui2", path = "../gpui2" }
fs = { package = "fs2", path = "../fs2" }
lsp = { package = "lsp2", path = "../lsp2" }
node_runtime = { path = "../node_runtime"}
util = { path = "../util" }
@ -30,6 +30,6 @@ futures.workspace = true
parking_lot.workspace = true
[dev-dependencies]
language2 = { path = "../language2", features = ["test-support"] }
gpui2 = { path = "../gpui2", features = ["test-support"] }
fs2 = { path = "../fs2", features = ["test-support"] }
language = { package = "language2", path = "../language2", features = ["test-support"] }
gpui = { package = "gpui2", path = "../gpui2", features = ["test-support"] }
fs = { package = "fs2", path = "../fs2", features = ["test-support"] }

14
crates/prettier2/src/prettier2.rs
View File

@ -1,9 +1,9 @@
use anyhow::Context;
use collections::HashMap;
use fs2::Fs;
use gpui2::{AsyncAppContext, Model};
use language2::{language_settings::language_settings, Buffer, Diff};
use lsp2::{LanguageServer, LanguageServerId};
use fs::Fs;
use gpui::{AsyncAppContext, Model};
use language::{language_settings::language_settings, Buffer, Diff};
use lsp::{LanguageServer, LanguageServerId};
use node_runtime::NodeRuntime;
use serde::{Deserialize, Serialize};
use std::{
@ -141,7 +141,7 @@ impl Prettier {
node: Arc<dyn NodeRuntime>,
cx: AsyncAppContext,
) -> anyhow::Result<Self> {
use lsp2::LanguageServerBinary;
use lsp::LanguageServerBinary;
let executor = cx.background_executor().clone();
anyhow::ensure!(
@ -453,7 +453,7 @@ struct FormatResult {
text: String,
}
impl lsp2::request::Request for Format {
impl lsp::request::Request for Format {
type Params = FormatParams;
type Result = FormatResult;
const METHOD: &'static str = "prettier/format";
@ -461,7 +461,7 @@ impl lsp2::request::Request for Format {
enum ClearCache {}
impl lsp2::request::Request for ClearCache {
impl lsp::request::Request for ClearCache {
type Params = ();
type Result = ();
const METHOD: &'static str = "prettier/clear_cache";

54
crates/project2/Cargo.toml
View File

@ -10,35 +10,35 @@ doctest = false
[features]
test-support = [
"client2/test-support",
"db2/test-support",
"language2/test-support",
"settings2/test-support",
"client/test-support",
"db/test-support",
"language/test-support",
"settings/test-support",
"text/test-support",
"prettier2/test-support",
"gpui2/test-support",
"prettier/test-support",
"gpui/test-support",
]
[dependencies]
text = { path = "../text" }
copilot2 = { path = "../copilot2" }
client2 = { path = "../client2" }
copilot = { package = "copilot2", path = "../copilot2" }
client = { package = "client2", path = "../client2" }
clock = { path = "../clock" }
collections = { path = "../collections" }
db2 = { path = "../db2" }
fs2 = { path = "../fs2" }
db = { package = "db2", path = "../db2" }
fs = { package = "fs2", path = "../fs2" }
fsevent = { path = "../fsevent" }
fuzzy2 = { path = "../fuzzy2" }
fuzzy = { package = "fuzzy2", path = "../fuzzy2" }
git = { path = "../git" }
gpui2 = { path = "../gpui2" }
language2 = { path = "../language2" }
lsp2 = { path = "../lsp2" }
gpui = { package = "gpui2", path = "../gpui2" }
language = { package = "language2", path = "../language2" }
lsp = { package = "lsp2", path = "../lsp2" }
node_runtime = { path = "../node_runtime" }
prettier2 = { path = "../prettier2" }
rpc2 = { path = "../rpc2" }
settings2 = { path = "../settings2" }
prettier = { package = "prettier2", path = "../prettier2" }
rpc = { package = "rpc2", path = "../rpc2" }
settings = { package = "settings2", path = "../settings2" }
sum_tree = { path = "../sum_tree" }
terminal2 = { path = "../terminal2" }
terminal = { package = "terminal2", path = "../terminal2" }
util = { path = "../util" }
aho-corasick = "1.1"
@ -69,17 +69,17 @@ itertools = "0.10"
ctor.workspace = true
env_logger.workspace = true
pretty_assertions.workspace = true
client2 = { path = "../client2", features = ["test-support"] }
client = { package = "client2", path = "../client2", features = ["test-support"] }
collections = { path = "../collections", features = ["test-support"] }
db2 = { path = "../db2", features = ["test-support"] }
fs2 = { path = "../fs2", features = ["test-support"] }
gpui2 = { path = "../gpui2", features = ["test-support"] }
language2 = { path = "../language2", features = ["test-support"] }
lsp2 = { path = "../lsp2", features = ["test-support"] }
settings2 = { path = "../settings2", features = ["test-support"] }
prettier2 = { path = "../prettier2", features = ["test-support"] }
db = { package = "db2", path = "../db2", features = ["test-support"] }
fs = { package = "fs2", path = "../fs2", features = ["test-support"] }
gpui = { package = "gpui2", path = "../gpui2", features = ["test-support"] }
language = { package = "language2", path = "../language2", features = ["test-support"] }
lsp = { package = "lsp2", path = "../lsp2", features = ["test-support"] }
settings = { package = "settings2", path = "../settings2", features = ["test-support"] }
prettier = { package = "prettier2", path = "../prettier2", features = ["test-support"] }
util = { path = "../util", features = ["test-support"] }
rpc2 = { path = "../rpc2", features = ["test-support"] }
rpc = { package = "rpc2", path = "../rpc2", features = ["test-support"] }
git2.workspace = true
tempdir.workspace = true
unindent.workspace = true

374
crates/project2/src/lsp_command.rs
View File

@ -5,10 +5,10 @@ use crate::{
};
use anyhow::{anyhow, Context, Result};
use async_trait::async_trait;
use client2::proto::{self, PeerId};
use client::proto::{self, PeerId};
use futures::future;
use gpui2::{AppContext, AsyncAppContext, Model};
use language2::{
use gpui::{AppContext, AsyncAppContext, Model};
use language::{
language_settings::{language_settings, InlayHintKind},
point_from_lsp, point_to_lsp,
proto::{deserialize_anchor, deserialize_version, serialize_anchor, serialize_version},
@ -16,29 +16,29 @@ use language2::{
CodeAction, Completion, OffsetRangeExt, PointUtf16, ToOffset, ToPointUtf16, Transaction,
Unclipped,
};
use lsp2::{
use lsp::{
CompletionListItemDefaultsEditRange, DocumentHighlightKind, LanguageServer, LanguageServerId,
OneOf, ServerCapabilities,
};
use std::{cmp::Reverse, ops::Range, path::Path, sync::Arc};
use text::LineEnding;
pub fn lsp_formatting_options(tab_size: u32) -> lsp2::FormattingOptions {
lsp2::FormattingOptions {
pub fn lsp_formatting_options(tab_size: u32) -> lsp::FormattingOptions {
lsp::FormattingOptions {
tab_size,
insert_spaces: true,
insert_final_newline: Some(true),
..lsp2::FormattingOptions::default()
..lsp::FormattingOptions::default()
}
}
#[async_trait(?Send)]
pub(crate) trait LspCommand: 'static + Sized + Send {
type Response: 'static + Default + Send;
type LspRequest: 'static + Send + lsp2::request::Request;
type LspRequest: 'static + Send + lsp::request::Request;
type ProtoRequest: 'static + Send + proto::RequestMessage;
fn check_capabilities(&self, _: &lsp2::ServerCapabilities) -> bool {
fn check_capabilities(&self, _: &lsp::ServerCapabilities) -> bool {
true
}
@ -48,11 +48,11 @@ pub(crate) trait LspCommand: 'static + Sized + Send {
buffer: &Buffer,
language_server: &Arc<LanguageServer>,
cx: &AppContext,
) -> <Self::LspRequest as lsp2::request::Request>::Params;
) -> <Self::LspRequest as lsp::request::Request>::Params;
async fn response_from_lsp(
self,
message: <Self::LspRequest as lsp2::request::Request>::Result,
message: <Self::LspRequest as lsp::request::Request>::Result,
project: Model<Project>,
buffer: Model<Buffer>,
server_id: LanguageServerId,
@ -140,8 +140,8 @@ pub(crate) struct FormattingOptions {
tab_size: u32,
}
impl From<lsp2::FormattingOptions> for FormattingOptions {
fn from(value: lsp2::FormattingOptions) -> Self {
impl From<lsp::FormattingOptions> for FormattingOptions {
fn from(value: lsp::FormattingOptions) -> Self {
Self {
tab_size: value.tab_size,
}
@ -151,11 +151,11 @@ impl From<lsp2::FormattingOptions> for FormattingOptions {
#[async_trait(?Send)]
impl LspCommand for PrepareRename {
type Response = Option<Range<Anchor>>;
type LspRequest = lsp2::request::PrepareRenameRequest;
type LspRequest = lsp::request::PrepareRenameRequest;
type ProtoRequest = proto::PrepareRename;
fn check_capabilities(&self, capabilities: &ServerCapabilities) -> bool {
if let Some(lsp2::OneOf::Right(rename)) = &capabilities.rename_provider {
if let Some(lsp::OneOf::Right(rename)) = &capabilities.rename_provider {
rename.prepare_provider == Some(true)
} else {
false
@ -168,10 +168,10 @@ impl LspCommand for PrepareRename {
_: &Buffer,
_: &Arc<LanguageServer>,
_: &AppContext,
) -> lsp2::TextDocumentPositionParams {
lsp2::TextDocumentPositionParams {
text_document: lsp2::TextDocumentIdentifier {
uri: lsp2::Url::from_file_path(path).unwrap(),
) -> lsp::TextDocumentPositionParams {
lsp::TextDocumentPositionParams {
text_document: lsp::TextDocumentIdentifier {
uri: lsp::Url::from_file_path(path).unwrap(),
},
position: point_to_lsp(self.position),
}
@ -179,7 +179,7 @@ impl LspCommand for PrepareRename {
async fn response_from_lsp(
self,
message: Option<lsp2::PrepareRenameResponse>,
message: Option<lsp::PrepareRenameResponse>,
_: Model<Project>,
buffer: Model<Buffer>,
_: LanguageServerId,
@ -187,8 +187,8 @@ impl LspCommand for PrepareRename {
) -> Result<Option<Range<Anchor>>> {
buffer.update(&mut cx, |buffer, _| {
if let Some(
lsp2::PrepareRenameResponse::Range(range)
| lsp2::PrepareRenameResponse::RangeWithPlaceholder { range, .. },
lsp::PrepareRenameResponse::Range(range)
| lsp::PrepareRenameResponse::RangeWithPlaceholder { range, .. },
) = message
{
let Range { start, end } = range_from_lsp(range);
@ -206,7 +206,7 @@ impl LspCommand for PrepareRename {
proto::PrepareRename {
project_id,
buffer_id: buffer.remote_id(),
position: Some(language2::proto::serialize_anchor(
position: Some(language::proto::serialize_anchor(
&buffer.anchor_before(self.position),
)),
version: serialize_version(&buffer.version()),
@ -245,10 +245,10 @@ impl LspCommand for PrepareRename {
can_rename: range.is_some(),
start: range
.as_ref()
.map(|range| language2::proto::serialize_anchor(&range.start)),
.map(|range| language::proto::serialize_anchor(&range.start)),
end: range
.as_ref()
.map(|range| language2::proto::serialize_anchor(&range.end)),
.map(|range| language::proto::serialize_anchor(&range.end)),
version: serialize_version(buffer_version),
}
}
@ -282,7 +282,7 @@ impl LspCommand for PrepareRename {
#[async_trait(?Send)]
impl LspCommand for PerformRename {
type Response = ProjectTransaction;
type LspRequest = lsp2::request::Rename;
type LspRequest = lsp::request::Rename;
type ProtoRequest = proto::PerformRename;
fn to_lsp(
@ -291,11 +291,11 @@ impl LspCommand for PerformRename {
_: &Buffer,
_: &Arc<LanguageServer>,
_: &AppContext,
) -> lsp2::RenameParams {
lsp2::RenameParams {
text_document_position: lsp2::TextDocumentPositionParams {
text_document: lsp2::TextDocumentIdentifier {
uri: lsp2::Url::from_file_path(path).unwrap(),
) -> lsp::RenameParams {
lsp::RenameParams {
text_document_position: lsp::TextDocumentPositionParams {
text_document: lsp::TextDocumentIdentifier {
uri: lsp::Url::from_file_path(path).unwrap(),
},
position: point_to_lsp(self.position),
},
@ -306,7 +306,7 @@ impl LspCommand for PerformRename {
async fn response_from_lsp(
self,
message: Option<lsp2::WorkspaceEdit>,
message: Option<lsp::WorkspaceEdit>,
project: Model<Project>,
buffer: Model<Buffer>,
server_id: LanguageServerId,
@ -333,7 +333,7 @@ impl LspCommand for PerformRename {
proto::PerformRename {
project_id,
buffer_id: buffer.remote_id(),
position: Some(language2::proto::serialize_anchor(
position: Some(language::proto::serialize_anchor(
&buffer.anchor_before(self.position),
)),
new_name: self.new_name.clone(),
@ -401,7 +401,7 @@ impl LspCommand for PerformRename {
#[async_trait(?Send)]
impl LspCommand for GetDefinition {
type Response = Vec<LocationLink>;
type LspRequest = lsp2::request::GotoDefinition;
type LspRequest = lsp::request::GotoDefinition;
type ProtoRequest = proto::GetDefinition;
fn to_lsp(
@ -410,11 +410,11 @@ impl LspCommand for GetDefinition {
_: &Buffer,
_: &Arc<LanguageServer>,
_: &AppContext,
) -> lsp2::GotoDefinitionParams {
lsp2::GotoDefinitionParams {
text_document_position_params: lsp2::TextDocumentPositionParams {
text_document: lsp2::TextDocumentIdentifier {
uri: lsp2::Url::from_file_path(path).unwrap(),
) -> lsp::GotoDefinitionParams {
lsp::GotoDefinitionParams {
text_document_position_params: lsp::TextDocumentPositionParams {
text_document: lsp::TextDocumentIdentifier {
uri: lsp::Url::from_file_path(path).unwrap(),
},
position: point_to_lsp(self.position),
},
@ -425,7 +425,7 @@ impl LspCommand for GetDefinition {
async fn response_from_lsp(
self,
message: Option<lsp2::GotoDefinitionResponse>,
message: Option<lsp::GotoDefinitionResponse>,
project: Model<Project>,
buffer: Model<Buffer>,
server_id: LanguageServerId,
@ -438,7 +438,7 @@ impl LspCommand for GetDefinition {
proto::GetDefinition {
project_id,
buffer_id: buffer.remote_id(),
position: Some(language2::proto::serialize_anchor(
position: Some(language::proto::serialize_anchor(
&buffer.anchor_before(self.position),
)),
version: serialize_version(&buffer.version()),
@ -494,13 +494,13 @@ impl LspCommand for GetDefinition {
#[async_trait(?Send)]
impl LspCommand for GetTypeDefinition {
type Response = Vec<LocationLink>;
type LspRequest = lsp2::request::GotoTypeDefinition;
type LspRequest = lsp::request::GotoTypeDefinition;
type ProtoRequest = proto::GetTypeDefinition;
fn check_capabilities(&self, capabilities: &ServerCapabilities) -> bool {
match &capabilities.type_definition_provider {
None => false,
Some(lsp2::TypeDefinitionProviderCapability::Simple(false)) => false,
Some(lsp::TypeDefinitionProviderCapability::Simple(false)) => false,
_ => true,
}
}
@ -511,11 +511,11 @@ impl LspCommand for GetTypeDefinition {
_: &Buffer,
_: &Arc<LanguageServer>,
_: &AppContext,
) -> lsp2::GotoTypeDefinitionParams {
lsp2::GotoTypeDefinitionParams {
text_document_position_params: lsp2::TextDocumentPositionParams {
text_document: lsp2::TextDocumentIdentifier {
uri: lsp2::Url::from_file_path(path).unwrap(),
) -> lsp::GotoTypeDefinitionParams {
lsp::GotoTypeDefinitionParams {
text_document_position_params: lsp::TextDocumentPositionParams {
text_document: lsp::TextDocumentIdentifier {
uri: lsp::Url::from_file_path(path).unwrap(),
},
position: point_to_lsp(self.position),
},
@ -526,7 +526,7 @@ impl LspCommand for GetTypeDefinition {
async fn response_from_lsp(
self,
message: Option<lsp2::GotoTypeDefinitionResponse>,
message: Option<lsp::GotoTypeDefinitionResponse>,
project: Model<Project>,
buffer: Model<Buffer>,
server_id: LanguageServerId,
@ -539,7 +539,7 @@ impl LspCommand for GetTypeDefinition {
proto::GetTypeDefinition {
project_id,
buffer_id: buffer.remote_id(),
position: Some(language2::proto::serialize_anchor(
position: Some(language::proto::serialize_anchor(
&buffer.anchor_before(self.position),
)),
version: serialize_version(&buffer.version()),
@ -670,7 +670,7 @@ async fn location_links_from_proto(
}
async fn location_links_from_lsp(
message: Option<lsp2::GotoDefinitionResponse>,
message: Option<lsp::GotoDefinitionResponse>,
project: Model<Project>,
buffer: Model<Buffer>,
server_id: LanguageServerId,
@ -683,15 +683,15 @@ async fn location_links_from_lsp(
let mut unresolved_links = Vec::new();
match message {
lsp2::GotoDefinitionResponse::Scalar(loc) => {
lsp::GotoDefinitionResponse::Scalar(loc) => {
unresolved_links.push((None, loc.uri, loc.range));
}
lsp2::GotoDefinitionResponse::Array(locs) => {
lsp::GotoDefinitionResponse::Array(locs) => {
unresolved_links.extend(locs.into_iter().map(|l| (None, l.uri, l.range)));
}
lsp2::GotoDefinitionResponse::Link(links) => {
lsp::GotoDefinitionResponse::Link(links) => {
unresolved_links.extend(links.into_iter().map(|l| {
(
l.origin_selection_range,
@ -786,7 +786,7 @@ fn location_links_to_proto(
#[async_trait(?Send)]
impl LspCommand for GetReferences {
type Response = Vec<Location>;
type LspRequest = lsp2::request::References;
type LspRequest = lsp::request::References;
type ProtoRequest = proto::GetReferences;
fn to_lsp(
@ -795,17 +795,17 @@ impl LspCommand for GetReferences {
_: &Buffer,
_: &Arc<LanguageServer>,
_: &AppContext,
) -> lsp2::ReferenceParams {
lsp2::ReferenceParams {
text_document_position: lsp2::TextDocumentPositionParams {
text_document: lsp2::TextDocumentIdentifier {
uri: lsp2::Url::from_file_path(path).unwrap(),
) -> lsp::ReferenceParams {
lsp::ReferenceParams {
text_document_position: lsp::TextDocumentPositionParams {
text_document: lsp::TextDocumentIdentifier {
uri: lsp::Url::from_file_path(path).unwrap(),
},
position: point_to_lsp(self.position),
},
work_done_progress_params: Default::default(),
partial_result_params: Default::default(),
context: lsp2::ReferenceContext {
context: lsp::ReferenceContext {
include_declaration: true,
},
}
@ -813,7 +813,7 @@ impl LspCommand for GetReferences {
async fn response_from_lsp(
self,
locations: Option<Vec<lsp2::Location>>,
locations: Option<Vec<lsp::Location>>,
project: Model<Project>,
buffer: Model<Buffer>,
server_id: LanguageServerId,
@ -859,7 +859,7 @@ impl LspCommand for GetReferences {
proto::GetReferences {
project_id,
buffer_id: buffer.remote_id(),
position: Some(language2::proto::serialize_anchor(
position: Some(language::proto::serialize_anchor(
&buffer.anchor_before(self.position),
)),
version: serialize_version(&buffer.version()),
@ -948,7 +948,7 @@ impl LspCommand for GetReferences {
#[async_trait(?Send)]
impl LspCommand for GetDocumentHighlights {
type Response = Vec<DocumentHighlight>;
type LspRequest = lsp2::request::DocumentHighlightRequest;
type LspRequest = lsp::request::DocumentHighlightRequest;
type ProtoRequest = proto::GetDocumentHighlights;
fn check_capabilities(&self, capabilities: &ServerCapabilities) -> bool {
@ -961,11 +961,11 @@ impl LspCommand for GetDocumentHighlights {
_: &Buffer,
_: &Arc<LanguageServer>,
_: &AppContext,
) -> lsp2::DocumentHighlightParams {
lsp2::DocumentHighlightParams {
text_document_position_params: lsp2::TextDocumentPositionParams {
text_document: lsp2::TextDocumentIdentifier {
uri: lsp2::Url::from_file_path(path).unwrap(),
) -> lsp::DocumentHighlightParams {
lsp::DocumentHighlightParams {
text_document_position_params: lsp::TextDocumentPositionParams {
text_document: lsp::TextDocumentIdentifier {
uri: lsp::Url::from_file_path(path).unwrap(),
},
position: point_to_lsp(self.position),
},
@ -976,7 +976,7 @@ impl LspCommand for GetDocumentHighlights {
async fn response_from_lsp(
self,
lsp_highlights: Option<Vec<lsp2::DocumentHighlight>>,
lsp_highlights: Option<Vec<lsp::DocumentHighlight>>,
_: Model<Project>,
buffer: Model<Buffer>,
_: LanguageServerId,
@ -996,7 +996,7 @@ impl LspCommand for GetDocumentHighlights {
range: buffer.anchor_after(start)..buffer.anchor_before(end),
kind: lsp_highlight
.kind
.unwrap_or(lsp2::DocumentHighlightKind::READ),
.unwrap_or(lsp::DocumentHighlightKind::READ),
}
})
.collect()
@ -1007,7 +1007,7 @@ impl LspCommand for GetDocumentHighlights {
proto::GetDocumentHighlights {
project_id,
buffer_id: buffer.remote_id(),
position: Some(language2::proto::serialize_anchor(
position: Some(language::proto::serialize_anchor(
&buffer.anchor_before(self.position),
)),
version: serialize_version(&buffer.version()),
@ -1099,7 +1099,7 @@ impl LspCommand for GetDocumentHighlights {
#[async_trait(?Send)]
impl LspCommand for GetHover {
type Response = Option<Hover>;
type LspRequest = lsp2::request::HoverRequest;
type LspRequest = lsp::request::HoverRequest;
type ProtoRequest = proto::GetHover;
fn to_lsp(
@ -1108,11 +1108,11 @@ impl LspCommand for GetHover {
_: &Buffer,
_: &Arc<LanguageServer>,
_: &AppContext,
) -> lsp2::HoverParams {
lsp2::HoverParams {
text_document_position_params: lsp2::TextDocumentPositionParams {
text_document: lsp2::TextDocumentIdentifier {
uri: lsp2::Url::from_file_path(path).unwrap(),
) -> lsp::HoverParams {
lsp::HoverParams {
text_document_position_params: lsp::TextDocumentPositionParams {
text_document: lsp::TextDocumentIdentifier {
uri: lsp::Url::from_file_path(path).unwrap(),
},
position: point_to_lsp(self.position),
},
@ -1122,7 +1122,7 @@ impl LspCommand for GetHover {
async fn response_from_lsp(
self,
message: Option<lsp2::Hover>,
message: Option<lsp::Hover>,
_: Model<Project>,
buffer: Model<Buffer>,
_: LanguageServerId,
@ -1144,15 +1144,13 @@ impl LspCommand for GetHover {
)
})?;
fn hover_blocks_from_marked_string(
marked_string: lsp2::MarkedString,
) -> Option<HoverBlock> {
fn hover_blocks_from_marked_string(marked_string: lsp::MarkedString) -> Option<HoverBlock> {
let block = match marked_string {
lsp2::MarkedString::String(content) => HoverBlock {
lsp::MarkedString::String(content) => HoverBlock {
text: content,
kind: HoverBlockKind::Markdown,
},
lsp2::MarkedString::LanguageString(lsp2::LanguageString { language, value }) => {
lsp::MarkedString::LanguageString(lsp::LanguageString { language, value }) => {
HoverBlock {
text: value,
kind: HoverBlockKind::Code { language },
@ -1167,18 +1165,18 @@ impl LspCommand for GetHover {
}
let contents = match hover.contents {
lsp2::HoverContents::Scalar(marked_string) => {
lsp::HoverContents::Scalar(marked_string) => {
hover_blocks_from_marked_string(marked_string)
.into_iter()
.collect()
}
lsp2::HoverContents::Array(marked_strings) => marked_strings
lsp::HoverContents::Array(marked_strings) => marked_strings
.into_iter()
.filter_map(hover_blocks_from_marked_string)
.collect(),
lsp2::HoverContents::Markup(markup_content) => vec![HoverBlock {
lsp::HoverContents::Markup(markup_content) => vec![HoverBlock {
text: markup_content.value,
kind: if markup_content.kind == lsp2::MarkupKind::Markdown {
kind: if markup_content.kind == lsp::MarkupKind::Markdown {
HoverBlockKind::Markdown
} else {
HoverBlockKind::PlainText
@ -1197,7 +1195,7 @@ impl LspCommand for GetHover {
proto::GetHover {
project_id,
buffer_id: buffer.remote_id(),
position: Some(language2::proto::serialize_anchor(
position: Some(language::proto::serialize_anchor(
&buffer.anchor_before(self.position),
)),
version: serialize_version(&buffer.version),
@ -1234,8 +1232,8 @@ impl LspCommand for GetHover {
if let Some(response) = response {
let (start, end) = if let Some(range) = response.range {
(
Some(language2::proto::serialize_anchor(&range.start)),
Some(language2::proto::serialize_anchor(&range.end)),
Some(language::proto::serialize_anchor(&range.start)),
Some(language::proto::serialize_anchor(&range.end)),
)
} else {
(None, None)
@ -1296,8 +1294,8 @@ impl LspCommand for GetHover {
let language = buffer.update(&mut cx, |buffer, _| buffer.language().cloned())?;
let range = if let (Some(start), Some(end)) = (message.start, message.end) {
language2::proto::deserialize_anchor(start)
.and_then(|start| language2::proto::deserialize_anchor(end).map(|end| start..end))
language::proto::deserialize_anchor(start)
.and_then(|start| language::proto::deserialize_anchor(end).map(|end| start..end))
} else {
None
};
@ -1317,7 +1315,7 @@ impl LspCommand for GetHover {
#[async_trait(?Send)]
impl LspCommand for GetCompletions {
type Response = Vec<Completion>;
type LspRequest = lsp2::request::Completion;
type LspRequest = lsp::request::Completion;
type ProtoRequest = proto::GetCompletions;
fn to_lsp(
@ -1326,10 +1324,10 @@ impl LspCommand for GetCompletions {
_: &Buffer,
_: &Arc<LanguageServer>,
_: &AppContext,
) -> lsp2::CompletionParams {
lsp2::CompletionParams {
text_document_position: lsp2::TextDocumentPositionParams::new(
lsp2::TextDocumentIdentifier::new(lsp2::Url::from_file_path(path).unwrap()),
) -> lsp::CompletionParams {
lsp::CompletionParams {
text_document_position: lsp::TextDocumentPositionParams::new(
lsp::TextDocumentIdentifier::new(lsp::Url::from_file_path(path).unwrap()),
point_to_lsp(self.position),
),
context: Default::default(),
@ -1340,7 +1338,7 @@ impl LspCommand for GetCompletions {
async fn response_from_lsp(
self,
completions: Option<lsp2::CompletionResponse>,
completions: Option<lsp::CompletionResponse>,
_: Model<Project>,
buffer: Model<Buffer>,
server_id: LanguageServerId,
@ -1349,9 +1347,9 @@ impl LspCommand for GetCompletions {
let mut response_list = None;
let completions = if let Some(completions) = completions {
match completions {
lsp2::CompletionResponse::Array(completions) => completions,
lsp::CompletionResponse::Array(completions) => completions,
lsp2::CompletionResponse::List(mut list) => {
lsp::CompletionResponse::List(mut list) => {
let items = std::mem::take(&mut list.items);
response_list = Some(list);
items
@ -1373,7 +1371,7 @@ impl LspCommand for GetCompletions {
let (old_range, mut new_text) = match lsp_completion.text_edit.as_ref() {
// If the language server provides a range to overwrite, then
// check that the range is valid.
Some(lsp2::CompletionTextEdit::Edit(edit)) => {
Some(lsp::CompletionTextEdit::Edit(edit)) => {
let range = range_from_lsp(edit.range);
let start = snapshot.clip_point_utf16(range.start, Bias::Left);
let end = snapshot.clip_point_utf16(range.end, Bias::Left);
@ -1439,7 +1437,7 @@ impl LspCommand for GetCompletions {
(range, text)
}
Some(lsp2::CompletionTextEdit::InsertAndReplace(_)) => {
Some(lsp::CompletionTextEdit::InsertAndReplace(_)) => {
log::info!("unsupported insert/replace completion");
return None;
}
@ -1457,7 +1455,7 @@ impl LspCommand for GetCompletions {
old_range,
new_text,
label: label.unwrap_or_else(|| {
language2::CodeLabel::plain(
language::CodeLabel::plain(
lsp_completion.label.clone(),
lsp_completion.filter_text.as_deref(),
)
@ -1477,7 +1475,7 @@ impl LspCommand for GetCompletions {
proto::GetCompletions {
project_id,
buffer_id: buffer.remote_id(),
position: Some(language2::proto::serialize_anchor(&anchor)),
position: Some(language::proto::serialize_anchor(&anchor)),
version: serialize_version(&buffer.version()),
}
}
@ -1494,7 +1492,7 @@ impl LspCommand for GetCompletions {
.await?;
let position = message
.position
.and_then(language2::proto::deserialize_anchor)
.and_then(language::proto::deserialize_anchor)
.map(|p| {
buffer.update(&mut cx, |buffer, _| {
buffer.clip_point_utf16(Unclipped(p.to_point_utf16(buffer)), Bias::Left)
@ -1514,7 +1512,7 @@ impl LspCommand for GetCompletions {
proto::GetCompletionsResponse {
completions: completions
.iter()
.map(language2::proto::serialize_completion)
.map(language::proto::serialize_completion)
.collect(),
version: serialize_version(&buffer_version),
}
@ -1535,7 +1533,7 @@ impl LspCommand for GetCompletions {
let language = buffer.update(&mut cx, |buffer, _| buffer.language().cloned())?;
let completions = message.completions.into_iter().map(|completion| {
language2::proto::deserialize_completion(completion, language.clone())
language::proto::deserialize_completion(completion, language.clone())
});
future::try_join_all(completions).await
}
@ -1548,13 +1546,13 @@ impl LspCommand for GetCompletions {
#[async_trait(?Send)]
impl LspCommand for GetCodeActions {
type Response = Vec<CodeAction>;
type LspRequest = lsp2::request::CodeActionRequest;
type LspRequest = lsp::request::CodeActionRequest;
type ProtoRequest = proto::GetCodeActions;
fn check_capabilities(&self, capabilities: &ServerCapabilities) -> bool {
match &capabilities.code_action_provider {
None => false,
Some(lsp2::CodeActionProviderCapability::Simple(false)) => false,
Some(lsp::CodeActionProviderCapability::Simple(false)) => false,
_ => true,
}
}
@ -1565,30 +1563,30 @@ impl LspCommand for GetCodeActions {
buffer: &Buffer,
language_server: &Arc<LanguageServer>,
_: &AppContext,
) -> lsp2::CodeActionParams {
) -> lsp::CodeActionParams {
let relevant_diagnostics = buffer
.snapshot()
.diagnostics_in_range::<_, usize>(self.range.clone(), false)
.map(|entry| entry.to_lsp_diagnostic_stub())
.collect();
lsp2::CodeActionParams {
text_document: lsp2::TextDocumentIdentifier::new(
lsp2::Url::from_file_path(path).unwrap(),
lsp::CodeActionParams {
text_document: lsp::TextDocumentIdentifier::new(
lsp::Url::from_file_path(path).unwrap(),
),
range: range_to_lsp(self.range.to_point_utf16(buffer)),
work_done_progress_params: Default::default(),
partial_result_params: Default::default(),
context: lsp2::CodeActionContext {
context: lsp::CodeActionContext {
diagnostics: relevant_diagnostics,
only: language_server.code_action_kinds(),
..lsp2::CodeActionContext::default()
..lsp::CodeActionContext::default()
},
}
}
async fn response_from_lsp(
self,
actions: Option<lsp2::CodeActionResponse>,
actions: Option<lsp::CodeActionResponse>,
_: Model<Project>,
_: Model<Buffer>,
server_id: LanguageServerId,
@ -1598,7 +1596,7 @@ impl LspCommand for GetCodeActions {
.unwrap_or_default()
.into_iter()
.filter_map(|entry| {
if let lsp2::CodeActionOrCommand::CodeAction(lsp_action) = entry {
if let lsp::CodeActionOrCommand::CodeAction(lsp_action) = entry {
Some(CodeAction {
server_id,
range: self.range.clone(),
@ -1615,8 +1613,8 @@ impl LspCommand for GetCodeActions {
proto::GetCodeActions {
project_id,
buffer_id: buffer.remote_id(),
start: Some(language2::proto::serialize_anchor(&self.range.start)),
end: Some(language2::proto::serialize_anchor(&self.range.end)),
start: Some(language::proto::serialize_anchor(&self.range.start)),
end: Some(language::proto::serialize_anchor(&self.range.end)),
version: serialize_version(&buffer.version()),
}
}
@ -1629,11 +1627,11 @@ impl LspCommand for GetCodeActions {
) -> Result<Self> {
let start = message
.start
.and_then(language2::proto::deserialize_anchor)
.and_then(language::proto::deserialize_anchor)
.ok_or_else(|| anyhow!("invalid start"))?;
let end = message
.end
.and_then(language2::proto::deserialize_anchor)
.and_then(language::proto::deserialize_anchor)
.ok_or_else(|| anyhow!("invalid end"))?;
buffer
.update(&mut cx, |buffer, _| {
@ -1654,7 +1652,7 @@ impl LspCommand for GetCodeActions {
proto::GetCodeActionsResponse {
actions: code_actions
.iter()
.map(language2::proto::serialize_code_action)
.map(language::proto::serialize_code_action)
.collect(),
version: serialize_version(&buffer_version),
}
@ -1675,7 +1673,7 @@ impl LspCommand for GetCodeActions {
message
.actions
.into_iter()
.map(language2::proto::deserialize_code_action)
.map(language::proto::deserialize_code_action)
.collect()
}
@ -1687,10 +1685,10 @@ impl LspCommand for GetCodeActions {
#[async_trait(?Send)]
impl LspCommand for OnTypeFormatting {
type Response = Option<Transaction>;
type LspRequest = lsp2::request::OnTypeFormatting;
type LspRequest = lsp::request::OnTypeFormatting;
type ProtoRequest = proto::OnTypeFormatting;
fn check_capabilities(&self, server_capabilities: &lsp2::ServerCapabilities) -> bool {
fn check_capabilities(&self, server_capabilities: &lsp::ServerCapabilities) -> bool {
let Some(on_type_formatting_options) =
&server_capabilities.document_on_type_formatting_provider
else {
@ -1712,10 +1710,10 @@ impl LspCommand for OnTypeFormatting {
_: &Buffer,
_: &Arc<LanguageServer>,
_: &AppContext,
) -> lsp2::DocumentOnTypeFormattingParams {
lsp2::DocumentOnTypeFormattingParams {
text_document_position: lsp2::TextDocumentPositionParams::new(
lsp2::TextDocumentIdentifier::new(lsp2::Url::from_file_path(path).unwrap()),
) -> lsp::DocumentOnTypeFormattingParams {
lsp::DocumentOnTypeFormattingParams {
text_document_position: lsp::TextDocumentPositionParams::new(
lsp::TextDocumentIdentifier::new(lsp::Url::from_file_path(path).unwrap()),
point_to_lsp(self.position),
),
ch: self.trigger.clone(),
@ -1725,7 +1723,7 @@ impl LspCommand for OnTypeFormatting {
async fn response_from_lsp(
self,
message: Option<Vec<lsp2::TextEdit>>,
message: Option<Vec<lsp::TextEdit>>,
project: Model<Project>,
buffer: Model<Buffer>,
server_id: LanguageServerId,
@ -1753,7 +1751,7 @@ impl LspCommand for OnTypeFormatting {
proto::OnTypeFormatting {
project_id,
buffer_id: buffer.remote_id(),
position: Some(language2::proto::serialize_anchor(
position: Some(language::proto::serialize_anchor(
&buffer.anchor_before(self.position),
)),
trigger: self.trigger.clone(),
@ -1798,7 +1796,7 @@ impl LspCommand for OnTypeFormatting {
) -> proto::OnTypeFormattingResponse {
proto::OnTypeFormattingResponse {
transaction: response
.map(|transaction| language2::proto::serialize_transaction(&transaction)),
.map(|transaction| language::proto::serialize_transaction(&transaction)),
}
}
@ -1812,9 +1810,7 @@ impl LspCommand for OnTypeFormatting {
let Some(transaction) = message.transaction else {
return Ok(None);
};
Ok(Some(language2::proto::deserialize_transaction(
transaction,
)?))
Ok(Some(language::proto::deserialize_transaction(transaction)?))
}
fn buffer_id_from_proto(message: &proto::OnTypeFormatting) -> u64 {
@ -1824,7 +1820,7 @@ impl LspCommand for OnTypeFormatting {
impl InlayHints {
pub async fn lsp_to_project_hint(
lsp_hint: lsp2::InlayHint,
lsp_hint: lsp::InlayHint,
buffer_handle: &Model<Buffer>,
server_id: LanguageServerId,
resolve_state: ResolveState,
@ -1832,8 +1828,8 @@ impl InlayHints {
cx: &mut AsyncAppContext,
) -> anyhow::Result<InlayHint> {
let kind = lsp_hint.kind.and_then(|kind| match kind {
lsp2::InlayHintKind::TYPE => Some(InlayHintKind::Type),
lsp2::InlayHintKind::PARAMETER => Some(InlayHintKind::Parameter),
lsp::InlayHintKind::TYPE => Some(InlayHintKind::Type),
lsp::InlayHintKind::PARAMETER => Some(InlayHintKind::Parameter),
_ => None,
});
@ -1861,12 +1857,12 @@ impl InlayHints {
label,
kind,
tooltip: lsp_hint.tooltip.map(|tooltip| match tooltip {
lsp2::InlayHintTooltip::String(s) => InlayHintTooltip::String(s),
lsp2::InlayHintTooltip::MarkupContent(markup_content) => {
lsp::InlayHintTooltip::String(s) => InlayHintTooltip::String(s),
lsp::InlayHintTooltip::MarkupContent(markup_content) => {
InlayHintTooltip::MarkupContent(MarkupContent {
kind: match markup_content.kind {
lsp2::MarkupKind::PlainText => HoverBlockKind::PlainText,
lsp2::MarkupKind::Markdown => HoverBlockKind::Markdown,
lsp::MarkupKind::PlainText => HoverBlockKind::PlainText,
lsp::MarkupKind::Markdown => HoverBlockKind::Markdown,
},
value: markup_content.value,
})
@ -1877,25 +1873,25 @@ impl InlayHints {
}
async fn lsp_inlay_label_to_project(
lsp_label: lsp2::InlayHintLabel,
lsp_label: lsp::InlayHintLabel,
server_id: LanguageServerId,
) -> anyhow::Result<InlayHintLabel> {
let label = match lsp_label {
lsp2::InlayHintLabel::String(s) => InlayHintLabel::String(s),
lsp2::InlayHintLabel::LabelParts(lsp_parts) => {
lsp::InlayHintLabel::String(s) => InlayHintLabel::String(s),
lsp::InlayHintLabel::LabelParts(lsp_parts) => {
let mut parts = Vec::with_capacity(lsp_parts.len());
for lsp_part in lsp_parts {
parts.push(InlayHintLabelPart {
value: lsp_part.value,
tooltip: lsp_part.tooltip.map(|tooltip| match tooltip {
lsp2::InlayHintLabelPartTooltip::String(s) => {
lsp::InlayHintLabelPartTooltip::String(s) => {
InlayHintLabelPartTooltip::String(s)
}
lsp2::InlayHintLabelPartTooltip::MarkupContent(markup_content) => {
lsp::InlayHintLabelPartTooltip::MarkupContent(markup_content) => {
InlayHintLabelPartTooltip::MarkupContent(MarkupContent {
kind: match markup_content.kind {
lsp2::MarkupKind::PlainText => HoverBlockKind::PlainText,
lsp2::MarkupKind::Markdown => HoverBlockKind::Markdown,
lsp::MarkupKind::PlainText => HoverBlockKind::PlainText,
lsp::MarkupKind::Markdown => HoverBlockKind::Markdown,
},
value: markup_content.value,
})
@ -1933,7 +1929,7 @@ impl InlayHints {
lsp_resolve_state,
});
proto::InlayHint {
position: Some(language2::proto::serialize_anchor(&response_hint.position)),
position: Some(language::proto::serialize_anchor(&response_hint.position)),
padding_left: response_hint.padding_left,
padding_right: response_hint.padding_right,
label: Some(proto::InlayHintLabel {
@ -1992,7 +1988,7 @@ impl InlayHints {
let resolve_state_data = resolve_state
.lsp_resolve_state.as_ref()
.map(|lsp_resolve_state| {
serde_json::from_str::<Option<lsp2::LSPAny>>(&lsp_resolve_state.value)
serde_json::from_str::<Option<lsp::LSPAny>>(&lsp_resolve_state.value)
.with_context(|| format!("incorrect proto inlay hint message: non-json resolve state {lsp_resolve_state:?}"))
.map(|state| (LanguageServerId(lsp_resolve_state.server_id as usize), state))
})
@ -2015,7 +2011,7 @@ impl InlayHints {
Ok(InlayHint {
position: message_hint
.position
.and_then(language2::proto::deserialize_anchor)
.and_then(language::proto::deserialize_anchor)
.context("invalid position")?,
label: match message_hint
.label
@ -2058,10 +2054,10 @@ impl InlayHints {
{
Some(((uri, range), server_id)) => Some((
LanguageServerId(server_id as usize),
lsp2::Location {
uri: lsp2::Url::parse(&uri)
lsp::Location {
uri: lsp::Url::parse(&uri)
.context("invalid uri in hint part {part:?}")?,
range: lsp2::Range::new(
range: lsp::Range::new(
point_to_lsp(PointUtf16::new(
range.start.row,
range.start.column,
@ -2107,22 +2103,22 @@ impl InlayHints {
})
}
pub fn project_to_lsp_hint(hint: InlayHint, snapshot: &BufferSnapshot) -> lsp2::InlayHint {
lsp2::InlayHint {
pub fn project_to_lsp_hint(hint: InlayHint, snapshot: &BufferSnapshot) -> lsp::InlayHint {
lsp::InlayHint {
position: point_to_lsp(hint.position.to_point_utf16(snapshot)),
kind: hint.kind.map(|kind| match kind {
InlayHintKind::Type => lsp2::InlayHintKind::TYPE,
InlayHintKind::Parameter => lsp2::InlayHintKind::PARAMETER,
InlayHintKind::Type => lsp::InlayHintKind::TYPE,
InlayHintKind::Parameter => lsp::InlayHintKind::PARAMETER,
}),
text_edits: None,
tooltip: hint.tooltip.and_then(|tooltip| {
Some(match tooltip {
InlayHintTooltip::String(s) => lsp2::InlayHintTooltip::String(s),
InlayHintTooltip::String(s) => lsp::InlayHintTooltip::String(s),
InlayHintTooltip::MarkupContent(markup_content) => {
lsp2::InlayHintTooltip::MarkupContent(lsp2::MarkupContent {
lsp::InlayHintTooltip::MarkupContent(lsp::MarkupContent {
kind: match markup_content.kind {
HoverBlockKind::PlainText => lsp2::MarkupKind::PlainText,
HoverBlockKind::Markdown => lsp2::MarkupKind::Markdown,
HoverBlockKind::PlainText => lsp::MarkupKind::PlainText,
HoverBlockKind::Markdown => lsp::MarkupKind::Markdown,
HoverBlockKind::Code { .. } => return None,
},
value: markup_content.value,
@ -2131,26 +2127,26 @@ impl InlayHints {
})
}),
label: match hint.label {
InlayHintLabel::String(s) => lsp2::InlayHintLabel::String(s),
InlayHintLabel::LabelParts(label_parts) => lsp2::InlayHintLabel::LabelParts(
InlayHintLabel::String(s) => lsp::InlayHintLabel::String(s),
InlayHintLabel::LabelParts(label_parts) => lsp::InlayHintLabel::LabelParts(
label_parts
.into_iter()
.map(|part| lsp2::InlayHintLabelPart {
.map(|part| lsp::InlayHintLabelPart {
value: part.value,
tooltip: part.tooltip.and_then(|tooltip| {
Some(match tooltip {
InlayHintLabelPartTooltip::String(s) => {
lsp2::InlayHintLabelPartTooltip::String(s)
lsp::InlayHintLabelPartTooltip::String(s)
}
InlayHintLabelPartTooltip::MarkupContent(markup_content) => {
lsp2::InlayHintLabelPartTooltip::MarkupContent(
lsp2::MarkupContent {
lsp::InlayHintLabelPartTooltip::MarkupContent(
lsp::MarkupContent {
kind: match markup_content.kind {
HoverBlockKind::PlainText => {
lsp2::MarkupKind::PlainText
lsp::MarkupKind::PlainText
}
HoverBlockKind::Markdown => {
lsp2::MarkupKind::Markdown
lsp::MarkupKind::Markdown
}
HoverBlockKind::Code { .. } => return None,
},
@ -2182,8 +2178,8 @@ impl InlayHints {
.and_then(|options| match options {
OneOf::Left(_is_supported) => None,
OneOf::Right(capabilities) => match capabilities {
lsp2::InlayHintServerCapabilities::Options(o) => o.resolve_provider,
lsp2::InlayHintServerCapabilities::RegistrationOptions(o) => {
lsp::InlayHintServerCapabilities::Options(o) => o.resolve_provider,
lsp::InlayHintServerCapabilities::RegistrationOptions(o) => {
o.inlay_hint_options.resolve_provider
}
},
@ -2195,18 +2191,18 @@ impl InlayHints {
#[async_trait(?Send)]
impl LspCommand for InlayHints {
type Response = Vec<InlayHint>;
type LspRequest = lsp2::InlayHintRequest;
type LspRequest = lsp::InlayHintRequest;
type ProtoRequest = proto::InlayHints;
fn check_capabilities(&self, server_capabilities: &lsp2::ServerCapabilities) -> bool {
fn check_capabilities(&self, server_capabilities: &lsp::ServerCapabilities) -> bool {
let Some(inlay_hint_provider) = &server_capabilities.inlay_hint_provider else {
return false;
};
match inlay_hint_provider {
lsp2::OneOf::Left(enabled) => *enabled,
lsp2::OneOf::Right(inlay_hint_capabilities) => match inlay_hint_capabilities {
lsp2::InlayHintServerCapabilities::Options(_) => true,
lsp2::InlayHintServerCapabilities::RegistrationOptions(_) => false,
lsp::OneOf::Left(enabled) => *enabled,
lsp::OneOf::Right(inlay_hint_capabilities) => match inlay_hint_capabilities {
lsp::InlayHintServerCapabilities::Options(_) => true,
lsp::InlayHintServerCapabilities::RegistrationOptions(_) => false,
},
}
}
@ -2217,10 +2213,10 @@ impl LspCommand for InlayHints {
buffer: &Buffer,
_: &Arc<LanguageServer>,
_: &AppContext,
) -> lsp2::InlayHintParams {
lsp2::InlayHintParams {
text_document: lsp2::TextDocumentIdentifier {
uri: lsp2::Url::from_file_path(path).unwrap(),
) -> lsp::InlayHintParams {
lsp::InlayHintParams {
text_document: lsp::TextDocumentIdentifier {
uri: lsp::Url::from_file_path(path).unwrap(),
},
range: range_to_lsp(self.range.to_point_utf16(buffer)),
work_done_progress_params: Default::default(),
@ -2229,7 +2225,7 @@ impl LspCommand for InlayHints {
async fn response_from_lsp(
self,
message: Option<Vec<lsp2::InlayHint>>,
message: Option<Vec<lsp::InlayHint>>,
project: Model<Project>,
buffer: Model<Buffer>,
server_id: LanguageServerId,
@ -2278,8 +2274,8 @@ impl LspCommand for InlayHints {
proto::InlayHints {
project_id,
buffer_id: buffer.remote_id(),
start: Some(language2::proto::serialize_anchor(&self.range.start)),
end: Some(language2::proto::serialize_anchor(&self.range.end)),
start: Some(language::proto::serialize_anchor(&self.range.start)),
end: Some(language::proto::serialize_anchor(&self.range.end)),
version: serialize_version(&buffer.version()),
}
}
@ -2292,11 +2288,11 @@ impl LspCommand for InlayHints {
) -> Result<Self> {
let start = message
.start
.and_then(language2::proto::deserialize_anchor)
.and_then(language::proto::deserialize_anchor)
.context("invalid start")?;
let end = message
.end
.and_then(language2::proto::deserialize_anchor)
.and_then(language::proto::deserialize_anchor)
.context("invalid end")?;
buffer
.update(&mut cx, |buffer, _| {

338
crates/project2/src/project2.rs
View File

File diff suppressed because it is too large Load Diff

4
crates/project2/src/project_settings.rs
View File

@ -1,8 +1,8 @@
use collections::HashMap;
use gpui2::AppContext;
use gpui::AppContext;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use settings2::Settings;
use settings::Settings;
use std::sync::Arc;
#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]

722
crates/project2/src/project_tests.rs
View File

File diff suppressed because it is too large Load Diff

4
crates/project2/src/search.rs
View File

@ -1,9 +1,9 @@
use aho_corasick::{AhoCorasick, AhoCorasickBuilder};
use anyhow::{Context, Result};
use client2::proto;
use client::proto;
use globset::{Glob, GlobMatcher};
use itertools::Itertools;
use language2::{char_kind, BufferSnapshot};
use language::{char_kind, BufferSnapshot};
use regex::{Regex, RegexBuilder};
use smol::future::yield_now;
use std::{

10
crates/project2/src/terminals.rs
View File

@ -1,8 +1,8 @@
use crate::Project;
use gpui2::{AnyWindowHandle, Context, Entity, Model, ModelContext, WeakModel};
use settings2::Settings;
use gpui::{AnyWindowHandle, Context, Entity, Model, ModelContext, WeakModel};
use settings::Settings;
use std::path::{Path, PathBuf};
use terminal2::{
use terminal::{
terminal_settings::{self, TerminalSettings, VenvSettingsContent},
Terminal, TerminalBuilder,
};
@ -11,7 +11,7 @@ use terminal2::{
use std::os::unix::ffi::OsStrExt;
pub struct Terminals {
pub(crate) local_handles: Vec<WeakModel<terminal2::Terminal>>,
pub(crate) local_handles: Vec<WeakModel<terminal::Terminal>>,
}
impl Project {
@ -121,7 +121,7 @@ impl Project {
}
}
pub fn local_terminal_handles(&self) -> &Vec<WeakModel<terminal2::Terminal>> {
pub fn local_terminal_handles(&self) -> &Vec<WeakModel<terminal::Terminal>> {
&self.terminals.local_handles
}
}

32
crates/project2/src/worktree.rs
View File

@ -3,10 +3,10 @@ use crate::{
};
use ::ignore::gitignore::{Gitignore, GitignoreBuilder};
use anyhow::{anyhow, Context as _, Result};
use client2::{proto, Client};
use client::{proto, Client};
use clock::ReplicaId;
use collections::{HashMap, HashSet, VecDeque};
use fs2::{
use fs::{
repository::{GitFileStatus, GitRepository, RepoPath},
Fs,
};
@ -19,20 +19,20 @@ use futures::{
task::Poll,
FutureExt as _, Stream, StreamExt,
};
use fuzzy2::CharBag;
use fuzzy::CharBag;
use git::{DOT_GIT, GITIGNORE};
use gpui2::{
use gpui::{
AppContext, AsyncAppContext, BackgroundExecutor, Context, EventEmitter, Model, ModelContext,
Task,
};
use language2::{
use language::{
proto::{
deserialize_fingerprint, deserialize_version, serialize_fingerprint, serialize_line_ending,
serialize_version,
},
Buffer, DiagnosticEntry, File as _, LineEnding, PointUtf16, Rope, RopeFingerprint, Unclipped,
};
use lsp2::LanguageServerId;
use lsp::LanguageServerId;
use parking_lot::Mutex;
use postage::{
barrier,
@ -2587,8 +2587,8 @@ pub struct File {
pub(crate) is_deleted: bool,
}
impl language2::File for File {
fn as_local(&self) -> Option<&dyn language2::LocalFile> {
impl language::File for File {
fn as_local(&self) -> Option<&dyn language::LocalFile> {
if self.is_local {
Some(self)
} else {
@ -2648,8 +2648,8 @@ impl language2::File for File {
self
}
fn to_proto(&self) -> rpc2::proto::File {
rpc2::proto::File {
fn to_proto(&self) -> rpc::proto::File {
rpc::proto::File {
worktree_id: self.worktree.entity_id().as_u64(),
entry_id: self.entry_id.to_proto(),
path: self.path.to_string_lossy().into(),
@ -2659,7 +2659,7 @@ impl language2::File for File {
}
}
impl language2::LocalFile for File {
impl language::LocalFile for File {
fn abs_path(&self, cx: &AppContext) -> PathBuf {
let worktree_path = &self.worktree.read(cx).as_local().unwrap().abs_path;
if self.path.as_ref() == Path::new("") {
@ -2716,7 +2716,7 @@ impl File {
}
pub fn from_proto(
proto: rpc2::proto::File,
proto: rpc::proto::File,
worktree: Model<Worktree>,
cx: &AppContext,
) -> Result<Self> {
@ -2740,7 +2740,7 @@ impl File {
})
}
pub fn from_dyn(file: Option<&Arc<dyn language2::File>>) -> Option<&Self> {
pub fn from_dyn(file: Option<&Arc<dyn language::File>>) -> Option<&Self> {
file.and_then(|f| f.as_any().downcast_ref())
}
@ -2818,7 +2818,7 @@ pub type UpdatedGitRepositoriesSet = Arc<[(Arc<Path>, GitRepositoryChange)]>;
impl Entry {
fn new(
path: Arc<Path>,
metadata: &fs2::Metadata,
metadata: &fs::Metadata,
next_entry_id: &AtomicUsize,
root_char_bag: CharBag,
) -> Self {
@ -4037,7 +4037,7 @@ pub trait WorktreeModelHandle {
#[cfg(any(test, feature = "test-support"))]
fn flush_fs_events<'a>(
&self,
cx: &'a mut gpui2::TestAppContext,
cx: &'a mut gpui::TestAppContext,
) -> futures::future::LocalBoxFuture<'a, ()>;
}
@ -4051,7 +4051,7 @@ impl WorktreeModelHandle for Model<Worktree> {
#[cfg(any(test, feature = "test-support"))]
fn flush_fs_events<'a>(
&self,
cx: &'a mut gpui2::TestAppContext,
cx: &'a mut gpui::TestAppContext,
) -> futures::future::LocalBoxFuture<'a, ()> {
let file_name = "fs-event-sentinel";

6
crates/rpc2/Cargo.toml
View File

@ -10,12 +10,12 @@ path = "src/rpc.rs"
doctest = false
[features]
test-support = ["collections/test-support", "gpui2/test-support"]
test-support = ["collections/test-support", "gpui/test-support"]
[dependencies]
clock = { path = "../clock" }
collections = { path = "../collections" }
gpui2 = { path = "../gpui2", optional = true }
gpui = { package = "gpui2", path = "../gpui2", optional = true }
util = { path = "../util" }
anyhow.workspace = true
async-lock = "2.4"
@ -37,7 +37,7 @@ prost-build = "0.9"
[dev-dependencies]
collections = { path = "../collections", features = ["test-support"] }
gpui2 = { path = "../gpui2", features = ["test-support"] }
gpui = { package = "gpui2", path = "../gpui2", features = ["test-support"] }
smol.workspace = true
tempdir.workspace = true
ctor.workspace = true

4
crates/rpc2/src/conn.rs
View File

@ -34,7 +34,7 @@ impl Connection {
#[cfg(any(test, feature = "test-support"))]
pub fn in_memory(
executor: gpui2::BackgroundExecutor,
executor: gpui::BackgroundExecutor,
) -> (Self, Self, std::sync::Arc<std::sync::atomic::AtomicBool>) {
use std::sync::{
atomic::{AtomicBool, Ordering::SeqCst},
@ -53,7 +53,7 @@ impl Connection {
#[allow(clippy::type_complexity)]
fn channel(
killed: Arc<AtomicBool>,
executor: gpui2::BackgroundExecutor,
executor: gpui::BackgroundExecutor,
) -> (
Box<dyn Send + Unpin + futures::Sink<WebSocketMessage, Error = anyhow::Error>>,
Box<dyn Send + Unpin + futures::Stream<Item = Result<WebSocketMessage, anyhow::Error>>>,

14
crates/rpc2/src/peer.rs
View File

@ -342,7 +342,7 @@ impl Peer {
pub fn add_test_connection(
self: &Arc<Self>,
connection: Connection,
executor: gpui2::BackgroundExecutor,
executor: gpui::BackgroundExecutor,
) -> (
ConnectionId,
impl Future<Output = anyhow::Result<()>> + Send,
@ -557,7 +557,7 @@ mod tests {
use super::*;
use crate::TypedEnvelope;
use async_tungstenite::tungstenite::Message as WebSocketMessage;
use gpui2::TestAppContext;
use gpui::TestAppContext;
fn init_logger() {
if std::env::var("RUST_LOG").is_ok() {
@ -565,7 +565,7 @@ mod tests {
}
}
#[gpui2::test(iterations = 50)]
#[gpui::test(iterations = 50)]
async fn test_request_response(cx: &mut TestAppContext) {
init_logger();
@ -663,7 +663,7 @@ mod tests {
}
}
#[gpui2::test(iterations = 50)]
#[gpui::test(iterations = 50)]
async fn test_order_of_response_and_incoming(cx: &mut TestAppContext) {
let executor = cx.executor();
let server = Peer::new(0);
@ -761,7 +761,7 @@ mod tests {
);
}
#[gpui2::test(iterations = 50)]
#[gpui::test(iterations = 50)]
async fn test_dropping_request_before_completion(cx: &mut TestAppContext) {
let executor = cx.executor().clone();
let server = Peer::new(0);
@ -873,7 +873,7 @@ mod tests {
);
}
#[gpui2::test(iterations = 50)]
#[gpui::test(iterations = 50)]
async fn test_disconnect(cx: &mut TestAppContext) {
let executor = cx.executor();
@ -909,7 +909,7 @@ mod tests {
.is_err());
}
#[gpui2::test(iterations = 50)]
#[gpui::test(iterations = 50)]
async fn test_io_error(cx: &mut TestAppContext) {
let executor = cx.executor();
let (client_conn, mut server_conn, _kill) = Connection::in_memory(executor.clone());

4
crates/rpc2/src/proto.rs
View File

@ -616,7 +616,7 @@ pub fn split_worktree_update(
mod tests {
use super::*;
#[gpui2::test]
#[gpui::test]
async fn test_buffer_size() {
let (tx, rx) = futures::channel::mpsc::unbounded();
let mut sink = MessageStream::new(tx.sink_map_err(|_| anyhow!("")));
@ -648,7 +648,7 @@ mod tests {
assert!(stream.encoding_buffer.capacity() <= MAX_BUFFER_LEN);
}
#[gpui2::test]
#[gpui::test]
fn test_converting_peer_id_from_and_to_u64() {
let peer_id = PeerId {
owner_id: 10,

12
crates/settings2/Cargo.toml
View File

@ -9,14 +9,14 @@ path = "src/settings2.rs"
doctest = false
[features]
test-support = ["gpui2/test-support", "fs/test-support"]
test-support = ["gpui/test-support", "fs/test-support"]
[dependencies]
collections = { path = "../collections" }
gpui2 = { path = "../gpui2" }
gpui = {package = "gpui2", path = "../gpui2" }
sqlez = { path = "../sqlez" }
fs2 = { path = "../fs2" }
feature_flags2 = { path = "../feature_flags2" }
fs = {package = "fs2", path = "../fs2" }
feature_flags = {package = "feature_flags2", path = "../feature_flags2" }
util = { path = "../util" }
anyhow.workspace = true
@ -35,8 +35,8 @@ tree-sitter.workspace = true
tree-sitter-json = "*"
[dev-dependencies]
gpui2 = { path = "../gpui2", features = ["test-support"] }
fs = { path = "../fs", features = ["test-support"] }
gpui = {package = "gpui2", path = "../gpui2", features = ["test-support"] }
fs = { package = "fs2", path = "../fs2", features = ["test-support"] }
indoc.workspace = true
pretty_assertions.workspace = true
unindent.workspace = true

4
crates/settings2/src/keymap_file.rs
View File

@ -1,7 +1,7 @@
use crate::{settings_store::parse_json_with_comments, SettingsAssets};
use anyhow::{anyhow, Context, Result};
use collections::BTreeMap;
use gpui2::{AppContext, KeyBinding, SharedString};
use gpui::{AppContext, KeyBinding, SharedString};
use schemars::{
gen::{SchemaGenerator, SchemaSettings},
schema::{InstanceType, Schema, SchemaObject, SingleOrVec, SubschemaValidation},
@ -137,7 +137,7 @@ impl KeymapFile {
}
}
fn no_action() -> Box<dyn gpui2::Action> {
fn no_action() -> Box<dyn gpui::Action> {
todo!()
}

4
crates/settings2/src/settings_file.rs
View File

@ -1,8 +1,8 @@
use crate::{settings_store::SettingsStore, Settings};
use anyhow::Result;
use fs2::Fs;
use fs::Fs;
use futures::{channel::mpsc, StreamExt};
use gpui2::{AppContext, BackgroundExecutor};
use gpui::{AppContext, BackgroundExecutor};
use std::{io::ErrorKind, path::PathBuf, str, sync::Arc, time::Duration};
use util::{paths, ResultExt};

8
crates/settings2/src/settings_store.rs
View File

@ -1,6 +1,6 @@
use anyhow::{anyhow, Context, Result};
use collections::{btree_map, hash_map, BTreeMap, HashMap};
use gpui2::AppContext;
use gpui::AppContext;
use lazy_static::lazy_static;
use schemars::{gen::SchemaGenerator, schema::RootSchema, JsonSchema};
use serde::{de::DeserializeOwned, Deserialize as _, Serialize};
@ -877,7 +877,7 @@ mod tests {
use serde_derive::Deserialize;
use unindent::Unindent;
#[gpui2::test]
#[gpui::test]
fn test_settings_store_basic(cx: &mut AppContext) {
let mut store = SettingsStore::default();
store.register_setting::<UserSettings>(cx);
@ -994,7 +994,7 @@ mod tests {
);
}
#[gpui2::test]
#[gpui::test]
fn test_setting_store_assign_json_before_register(cx: &mut AppContext) {
let mut store = SettingsStore::default();
store
@ -1037,7 +1037,7 @@ mod tests {
);
}
#[gpui2::test]
#[gpui::test]
fn test_setting_store_update(cx: &mut AppContext) {
let mut store = SettingsStore::default();
store.register_setting::<MultiKeySettings>(cx);

4
crates/storybook2/src/storybook2.rs
View File

@ -82,8 +82,8 @@ fn main() {
..Default::default()
},
move |cx| {
let theme_settings = ThemeSettings::get_global(cx);
cx.set_rem_size(theme_settings.ui_font_size);
let ui_font_size = ThemeSettings::get_global(cx).ui_font_size;
cx.set_rem_size(ui_font_size);
cx.build_view(|cx| StoryWrapper::new(selector.story(cx)))
},

8
crates/terminal2/Cargo.toml
View File

@ -10,10 +10,10 @@ doctest = false
[dependencies]
gpui2 = { path = "../gpui2" }
settings2 = { path = "../settings2" }
db2 = { path = "../db2" }
theme2 = { path = "../theme2" }
gpui = { package = "gpui2", path = "../gpui2" }
settings = { package = "settings2", path = "../settings2" }
db = { package = "db2", path = "../db2" }
theme = { package = "theme2", path = "../theme2" }
util = { path = "../util" }
alacritty_terminal = { git = "https://github.com/zed-industries/alacritty", rev = "33306142195b354ef3485ca2b1d8a85dfc6605ca" }

2
crates/terminal2/src/mappings/colors.rs
View File

@ -113,7 +113,7 @@ use alacritty_terminal::term::color::Rgb as AlacRgb;
// let b = (i % 36) % 6;
// (r, g, b)
// }
use gpui2::Rgba;
use gpui::Rgba;
//Convenience method to convert from a GPUI color to an alacritty Rgb
pub fn to_alac_rgb(color: impl Into<Rgba>) -> AlacRgb {

4
crates/terminal2/src/mappings/keys.rs
View File

@ -1,6 +1,6 @@
/// The mappings defined in this file where created from reading the alacritty source
use alacritty_terminal::term::TermMode;
use gpui2::Keystroke;
use gpui::Keystroke;
#[derive(Debug, PartialEq, Eq)]
enum AlacModifiers {
@ -278,7 +278,7 @@ fn modifier_code(keystroke: &Keystroke) -> u32 {
#[cfg(test)]
mod test {
use gpui2::Modifiers;
use gpui::Modifiers;
use super::*;

24
crates/terminal2/src/mappings/mouse.rs
View File

@ -6,7 +6,7 @@ use alacritty_terminal::grid::Dimensions;
/// with modifications for our circumstances
use alacritty_terminal::index::{Column as GridCol, Line as GridLine, Point as AlacPoint, Side};
use alacritty_terminal::term::TermMode;
use gpui2::{px, Modifiers, MouseButton, MouseMoveEvent, Pixels, Point, ScrollWheelEvent};
use gpui::{px, Modifiers, MouseButton, MouseMoveEvent, Pixels, Point, ScrollWheelEvent};
use crate::TerminalSize;
@ -45,10 +45,10 @@ impl AlacMouseButton {
fn from_move(e: &MouseMoveEvent) -> Self {
match e.pressed_button {
Some(b) => match b {
gpui2::MouseButton::Left => AlacMouseButton::LeftMove,
gpui2::MouseButton::Middle => AlacMouseButton::MiddleMove,
gpui2::MouseButton::Right => AlacMouseButton::RightMove,
gpui2::MouseButton::Navigate(_) => AlacMouseButton::Other,
gpui::MouseButton::Left => AlacMouseButton::LeftMove,
gpui::MouseButton::Middle => AlacMouseButton::MiddleMove,
gpui::MouseButton::Right => AlacMouseButton::RightMove,
gpui::MouseButton::Navigate(_) => AlacMouseButton::Other,
},
None => AlacMouseButton::NoneMove,
}
@ -56,17 +56,17 @@ impl AlacMouseButton {
fn from_button(e: MouseButton) -> Self {
match e {
gpui2::MouseButton::Left => AlacMouseButton::LeftButton,
gpui2::MouseButton::Right => AlacMouseButton::MiddleButton,
gpui2::MouseButton::Middle => AlacMouseButton::RightButton,
gpui2::MouseButton::Navigate(_) => AlacMouseButton::Other,
gpui::MouseButton::Left => AlacMouseButton::LeftButton,
gpui::MouseButton::Right => AlacMouseButton::MiddleButton,
gpui::MouseButton::Middle => AlacMouseButton::RightButton,
gpui::MouseButton::Navigate(_) => AlacMouseButton::Other,
}
}
fn from_scroll(e: &ScrollWheelEvent) -> Self {
let is_positive = match e.delta {
gpui2::ScrollDelta::Pixels(pixels) => pixels.y > px(0.),
gpui2::ScrollDelta::Lines(lines) => lines.y > 0.,
gpui::ScrollDelta::Pixels(pixels) => pixels.y > px(0.),
gpui::ScrollDelta::Lines(lines) => lines.y > 0.,
};
if is_positive {
@ -118,7 +118,7 @@ pub fn alt_scroll(scroll_lines: i32) -> Vec<u8> {
pub fn mouse_button_report(
point: AlacPoint,
button: gpui2::MouseButton,
button: gpui::MouseButton,
modifiers: Modifiers,
pressed: bool,
mode: TermMode,

6
crates/terminal2/src/terminal2.rs
View File

@ -33,7 +33,7 @@ use mappings::mouse::{
use procinfo::LocalProcessInfo;
use serde::{Deserialize, Serialize};
use settings2::Settings;
use settings::Settings;
use terminal_settings::{AlternateScroll, Shell, TerminalBlink, TerminalSettings};
use util::truncate_and_trailoff;
@ -49,7 +49,7 @@ use std::{
};
use thiserror::Error;
use gpui2::{
use gpui::{
px, AnyWindowHandle, AppContext, Bounds, ClipboardItem, EventEmitter, Hsla, Keystroke,
ModelContext, Modifiers, MouseButton, MouseDownEvent, MouseMoveEvent, MouseUpEvent, Pixels,
Point, ScrollWheelEvent, Size, Task, TouchPhase,
@ -1409,7 +1409,7 @@ mod tests {
index::{Column, Line, Point as AlacPoint},
term::cell::Cell,
};
use gpui2::{point, size, Pixels};
use gpui::{point, size, Pixels};
use rand::{distributions::Alphanumeric, rngs::ThreadRng, thread_rng, Rng};
use crate::{content_index_for_mouse, IndexedCell, TerminalContent, TerminalSize};

4
crates/terminal2/src/terminal_settings.rs
View File

@ -1,4 +1,4 @@
use gpui2::{AppContext, FontFeatures};
use gpui::{AppContext, FontFeatures};
use schemars::JsonSchema;
use serde_derive::{Deserialize, Serialize};
use std::{collections::HashMap, path::PathBuf};
@ -98,7 +98,7 @@ impl TerminalSettings {
// }
}
impl settings2::Settings for TerminalSettings {
impl settings::Settings for TerminalSettings {
const KEY: Option<&'static str> = Some("terminal");
type FileContent = TerminalSettingsContent;

2
crates/text2/Cargo.toml
View File

@ -30,7 +30,7 @@ regex.workspace = true
[dev-dependencies]
collections = { path = "../collections", features = ["test-support"] }
gpui2 = { path = "../gpui2", features = ["test-support"] }
gpui = { package = "gpui2", path = "../gpui2", features = ["test-support"] }
util = { path = "../util", features = ["test-support"] }
ctor.workspace = true
env_logger.workspace = true

2
crates/text2/src/locator.rs
View File

@ -91,7 +91,7 @@ mod tests {
use rand::prelude::*;
use std::mem;
#[gpui2::test(iterations = 100)]
#[gpui::test(iterations = 100)]
fn test_locators(mut rng: StdRng) {
let mut lhs = Default::default();
let mut rhs = Default::default();

14
crates/text2/src/patch.rs
View File

@ -256,7 +256,7 @@ mod tests {
use rand::prelude::*;
use std::env;
#[gpui2::test]
#[gpui::test]
fn test_one_disjoint_edit() {
assert_patch_composition(
Patch(vec![Edit {
@ -301,7 +301,7 @@ mod tests {
);
}
#[gpui2::test]
#[gpui::test]
fn test_one_overlapping_edit() {
assert_patch_composition(
Patch(vec![Edit {
@ -319,7 +319,7 @@ mod tests {
);
}
#[gpui2::test]
#[gpui::test]
fn test_two_disjoint_and_overlapping() {
assert_patch_composition(
Patch(vec![
@ -355,7 +355,7 @@ mod tests {
);
}
#[gpui2::test]
#[gpui::test]
fn test_two_new_edits_overlapping_one_old_edit() {
assert_patch_composition(
Patch(vec![Edit {
@ -421,7 +421,7 @@ mod tests {
);
}
#[gpui2::test]
#[gpui::test]
fn test_two_new_edits_touching_one_old_edit() {
assert_patch_composition(
Patch(vec![
@ -457,7 +457,7 @@ mod tests {
);
}
#[gpui2::test]
#[gpui::test]
fn test_old_to_new() {
let patch = Patch(vec![
Edit {
@ -481,7 +481,7 @@ mod tests {
assert_eq!(patch.old_to_new(9), 12);
}
#[gpui2::test(iterations = 100)]
#[gpui::test(iterations = 100)]
fn test_random_patch_compositions(mut rng: StdRng) {
let operations = env::var("OPERATIONS")
.map(|i| i.parse().expect("invalid `OPERATIONS` variable"))

4
crates/text2/src/tests.rs
View File

@ -32,7 +32,7 @@ fn test_edit() {
assert_eq!(buffer.text(), "ghiamnoef");
}
#[gpui2::test(iterations = 100)]
#[gpui::test(iterations = 100)]
fn test_random_edits(mut rng: StdRng) {
let operations = env::var("OPERATIONS")
.map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
@ -687,7 +687,7 @@ fn test_concurrent_edits() {
assert_eq!(buffer3.text(), "a12c34e56");
}
#[gpui2::test(iterations = 100)]
#[gpui::test(iterations = 100)]
fn test_random_concurrent_edits(mut rng: StdRng) {
let peers = env::var("PEERS")
.map(|i| i.parse().expect("invalid `PEERS` variable"))

12
crates/theme2/Cargo.toml
View File

@ -6,9 +6,9 @@ publish = false
[features]
test-support = [
"gpui2/test-support",
"gpui/test-support",
"fs/test-support",
"settings2/test-support"
"settings/test-support"
]
[lib]
@ -18,7 +18,7 @@ doctest = false
[dependencies]
anyhow.workspace = true
fs = { path = "../fs" }
gpui2 = { path = "../gpui2" }
gpui = { package = "gpui2", path = "../gpui2" }
indexmap = "1.6.2"
parking_lot.workspace = true
refineable.workspace = true
@ -26,11 +26,11 @@ schemars.workspace = true
serde.workspace = true
serde_derive.workspace = true
serde_json.workspace = true
settings2 = { path = "../settings2" }
settings = { package = "settings2", path = "../settings2" }
toml.workspace = true
util = { path = "../util" }
[dev-dependencies]
gpui2 = { path = "../gpui2", features = ["test-support"] }
gpui = { package = "gpui2", path = "../gpui2", features = ["test-support"] }
fs = { path = "../fs", features = ["test-support"] }
settings2 = { path = "../settings2", features = ["test-support"] }
settings = { package = "settings2", path = "../settings2", features = ["test-support"] }

Some files were not shown because too many files have changed in this diff Show More