c463142 · helix · git.iko.soy

helix-core/src/syntax.rs+1−4

compare with master

unifiedsplit

@@ -57,10 +57,7 @@ pub struct LanguageConfiguration {

57 #[serde(skip)]

58 pub(crate) indent_query: OnceCell<Option<IndentQuery>>,

59 #[serde(skip_serializing_if = "Option::is_none")]

60− pub debug_adapter: Option<DebugAdapterConfig>,

60+ pub debugger: Option<DebugAdapterConfig>,

61− // TODO: names for those

62− #[serde(skip_serializing_if = "Option::is_none")]

63− pub debug_configs: Option<Vec<HashMap<String, serde_json::Value>>>,

64}

61}

65

62

66#[derive(Debug, Serialize, Deserialize)]

63#[derive(Debug, Serialize, Deserialize)]

helix-dap/src/client.rs+3−1

@@ -225,7 +225,9 @@ impl Client {

225 }

226

227 pub fn capabilities(&self) -> &DebuggerCapabilities {

228+ self.caps

229+ .as_ref()

228− self.caps.as_ref().expect("debugger not yet initialized!")

230+ .expect("debugger not yet initialized!")

229 }

231 }

230

232

231 pub async fn initialize(&mut self, adapter_id: String) -> Result<()> {

233 pub async fn initialize(&mut self, adapter_id: String) -> Result<()> {

helix-dap/src/types.rs+10−1

@@ -1,6 +1,14 @@

1use serde::{Deserialize, Serialize};

2use serde_json::Value;

3−use std::path::PathBuf;

3+use std::{collections::HashMap, path::PathBuf};

4+

5+#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]

6+#[serde(rename_all = "kebab-case")]

7+pub struct DebugTemplate {

8+ pub name: String,

9+ pub request: String,

10+ pub args: HashMap<String, Value>

11+}

4

12

5#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]

13#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]

6#[serde(rename_all = "kebab-case")]

14#[serde(rename_all = "kebab-case")]

@@ -10,6 +18,7 @@ pub struct DebugAdapterConfig {

10 pub command: String,

18 pub command: String,

11 pub args: Vec<String>,

19 pub args: Vec<String>,

12 pub port_arg: Option<String>,

20 pub port_arg: Option<String>,

21+ pub templates: Vec<DebugTemplate>,

13}

22}

14

23

15pub trait Request {

24pub trait Request {

helix-term/src/commands.rs+12−17

@@ -4392,7 +4392,6 @@ fn dap_start(cx: &mut Context) {

4392

4393 let (_, doc) = current!(cx.editor);

4394

4395− // TODO config picker

4396 let path = match doc.path() {

4395 let path = match doc.path() {

4397 Some(path) => path.to_path_buf(),

4396 Some(path) => path.to_path_buf(),

4398 None => {

4397 None => {

@@ -4406,7 +4405,7 @@ fn dap_start(cx: &mut Context) {

4406 .editor

4405 .editor

4407 .syn_loader

4406 .syn_loader

4408 .language_config_for_file_name(&path)

4407 .language_config_for_file_name(&path)

4409− .and_then(|x| x.debug_adapter.clone());

4408+ .and_then(|x| x.debugger.clone());

4410 let config = match config {

4409 let config = match config {

4411 Some(c) => c,

4410 Some(c) => c,

4412 None => {

4411 None => {

@@ -4416,30 +4415,26 @@ fn dap_start(cx: &mut Context) {

4416 return;

4415 return;

4417 }

4416 }

4418 };

4417 };

4418+

4419 let started = Client::process(config.clone(), 0);

4420 let (mut debugger, events) = block_on(started).unwrap();

4421

4422− let request = debugger.initialize(config.name);

4422+ let request = debugger.initialize(config.name.clone());

4423 let _ = block_on(request).unwrap();

4424

4425− let sessions = doc.language_config().and_then(|x| x.debug_configs.clone());

4425+ // TODO: picker

4426−

4426+ let start_config = config.templates.get(0).unwrap();

4427− let sessions = match sessions {

4427+ let args = to_value(start_config.args.clone()).unwrap();

4428− Some(c) => c,

4428+

4429− None => {

4429+ match &start_config.request[..] {

4430+ "launch" => block_on(debugger.launch(args)).unwrap(),

4431+ "attach" => block_on(debugger.attach(args)).unwrap(),

4432+ _ => {

4430− cx.editor.set_error(

4433+ cx.editor.set_error("Unsupported request".to_string());

4431− "Can't start debug: no debug sessions available for language".to_string(),

4432− );

4433 return;

4434 return;

4434 }

4435 }

4435 };

4436 };

4436

4437

4437− // TODO: picker

4438− let args = sessions.get(0);

4439−

4440− let request = debugger.launch(to_value(args).unwrap());

4441− let _ = block_on(request).unwrap();

4442−

4443 // TODO: either await "initialized" or buffer commands until event is received

4438 // TODO: either await "initialized" or buffer commands until event is received

4444 cx.editor.debugger = Some(debugger);

4439 cx.editor.debugger = Some(debugger);

4445 let stream = UnboundedReceiverStream::new(events);

4440 let stream = UnboundedReceiverStream::new(events);

languages.toml+21−27

@@ -19,11 +19,6 @@ config = """

19

20language-server = { command = "rust-analyzer" }

21indent = { tab-width = 4, unit = " " }

22−debug-adapter = { name = "lldb", transport = "tcp", command = "lldb-vscode", args = [], port-arg = "-p {}" }

23−

24−[[language.debug-configs]]

25−console = "internalConsole"

26−program = "target/debug/rustdebug"

27

22

28[[language]]

23[[language]]

29name = "toml"

24name = "toml"

@@ -74,11 +69,6 @@ comment-token = "//"

74

69

75language-server = { command = "clangd" }

70language-server = { command = "clangd" }

76indent = { tab-width = 2, unit = " " }

71indent = { tab-width = 2, unit = " " }

77−debug-adapter = { name = "lldb", transport = "tcp", command = "lldb-vscode", args = [], port-arg = "-p {}" }

78−

79−[[language.debug-configs]]

80−console = "internalConsole"

81−program = "main"

82

72

83[[language]]

73[[language]]

84name = "cpp"

74name = "cpp"

@@ -90,11 +80,6 @@ comment-token = "//"

90

80

91language-server = { command = "clangd" }

81language-server = { command = "clangd" }

92indent = { tab-width = 2, unit = " " }

82indent = { tab-width = 2, unit = " " }

93−debug-adapter = { name = "lldb", transport = "tcp", command = "lldb-vscode", args = [], port-arg = "-p {}" }

94−

95−[[language.debug-configs]]

96−console = "internalConsole"

97−program = "main"

98

83

99[[language]]

84[[language]]

100name = "go"

85name = "go"

@@ -108,19 +93,28 @@ comment-token = "//"

108language-server = { command = "gopls" }

93language-server = { command = "gopls" }

109# TODO: gopls needs utf-8 offsets?

94# TODO: gopls needs utf-8 offsets?

110indent = { tab-width = 4, unit = "\t" }

95indent = { tab-width = 4, unit = "\t" }

111−debug-adapter = { name = "go", transport = "tcp", command = "dlv", args = ["dap"], port-arg = "-l 127.0.0.1:{}" }

112

96

113−[[language.debug-configs]]

97+[language.debugger]

114−mode = "debug"

98+name = "go"

99+transport = "tcp"

100+command = "dlv"

101+args = ["dap"]

102+port-arg = "-l 127.0.0.1:{}"

103+

104+[[language.debugger.templates]]

105+name = "source"

106+request = "launch"

115−program = "main.go"

107+args = { mode = "debug", program = "main.go" }

116−

108+

117−[[language.debug-configs]]

109+[[language.debugger.templates]]

118−mode = "exec"

110+name = "binary"

111+request = "launch"

119−program = "main"

112+args = { mode = "exec", program = "main" }

120−

113+

121−[[language.debug-configs]]

114+[[language.debugger.templates]]

115+name = "test"

116+request = "launch"

122−mode = "test"

117+args = { mode = "test", program = "." }

123−program = "."

124

118

125[[language]]

119[[language]]

126name = "javascript"

120name = "javascript"