The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
fix(run): UTF-8 default charset for application JVMs forked by Maven and Gradle on Windows (#751)
l0ng-aie8d1c45970aa
diff --git a/crates/ide-core/src/output_encoding.rs b/crates/ide-core/src/output_encoding.rsindex de53b5409..f8f7f4027 100644--- a/crates/ide-core/src/output_encoding.rs+++ b/crates/ide-core/src/output_encoding.rs@@ -13,7 +13,10 @@//! they fork get them too (`spring-boot:run`, Surefire, `bootRun`, test workers).//! Each JVM then reports "Picked up JAVA_TOOL_OPTIONS: …" on stderr (which a build tool//! may copy to its stdout); that line is hidden again ([`NoticeFilter`]). `file.encoding` is left alone there: it would change-//! how a build reads sources that declare no encoding.+//! how a build reads sources that declare no encoding. The application JVMs a build+//! forks get `file.encoding=UTF-8` for a UTF-8 console instead, through the build's own+//! options: `-Dspring-boot.run.jvmArguments` for Maven `spring-boot:run`, an init script+//! ([`GRADLE_FILE_ENCODING_SCRIPT`]) for Gradle `JavaExec` tasks (`bootRun`, `run`).//! - Python: `PYTHONIOENCODING`.use std::collections::BTreeMap;@@ -75,16 +78,34 @@ fn encoding_for_code_page(cp: u32) -> Option<&'static encoding_rs::Encoding> {const STD_PROPERTIES: &[&str] = &["stdout.encoding", "stderr.encoding", "sun.stdout.encoding", "sun.stderr.encoding"];const FILE_ENCODING: &str = "file.encoding";const TOOL_OPTIONS: &str = "JAVA_TOOL_OPTIONS";+const SPRING_BOOT_JVM_ARGS: &str = "-Dspring-boot.run.jvmArguments=";/// Build tools and launcher scripts that run on (and may fork) JVMs.-const JVM_TOOLS: &[&str] =- &["mvn", "mvnw", "mvnd", "gradle", "gradlew", "sbt", "ant", "kotlin", "kotlinc", "groovy", "scala", "jbang"];+const JVM_TOOLS: &[&str] = &["sbt", "ant", "kotlin", "kotlinc", "groovy", "scala", "jbang"];+const MAVEN: &[&str] = &["mvn", "mvnw", "mvnd"];+const GRADLE: &[&str] = &["gradle", "gradlew"];++/// Gradle init script giving the `JavaExec` tasks (`bootRun`, `run`, custom ones) a UTF-8+/// default charset before the build configures them, so the build can override it.+/// Gradle's own JVM and the compiler's source encoding are untouched.+pub const GRADLE_FILE_ENCODING_SCRIPT: &str = "\+// Written by OpenIDEA: a UTF-8 default charset for applications run by Gradle, as the Run console decodes UTF-8.+allprojects {+ tasks.withType(JavaExec).configureEach {+ defaultCharacterEncoding = 'UTF-8'+ }+}+";/// What a launch needs: `-D` options to put first on a `java` command line,/// environment variables to set, and the notice line its JVMs print because of them.#[derive(Debug, Default, PartialEq, Eq)]pub struct EncodingFix {pub java_args: Vec<String>,+ /// The build tool's arguments, rewritten to pass options to the JVM it forks.+ pub args: Option<Vec<String>>,+ /// Gradle: pass [`GRADLE_FILE_ENCODING_SCRIPT`] with `--init-script`.+ pub gradle_init_script: bool,pub env: Vec<(String, String)>,/// "Picked up JAVA_TOOL_OPTIONS: …" for a variable set here alone, to drop from the output.pub notice: Option<String>,@@ -116,6 +137,8 @@ fn options(properties: &[&str], encoding: &str) -> Vec<String> {#[derive(Clone, Copy, PartialEq, Eq)]enum Kind {Java,+ Maven,+ Gradle,JvmTool,Python,Other,@@ -125,6 +148,10 @@ fn kind(program: &str) -> Kind {let name = program_name(program);if name == "java" || name == "javaw" {Kind::Java+ } else if MAVEN.contains(&name.as_str()) {+ Kind::Maven+ } else if GRADLE.contains(&name.as_str()) {+ Kind::Gradle} else if JVM_TOOLS.contains(&name.as_str()) {Kind::JvmTool} else if is_python(&name) {@@ -193,7 +220,17 @@ fn fix_kind(out.java_args.push(format!("-D{FILE_ENCODING}=UTF-8"));}}- (Kind::Java | Kind::JvmTool, _) => {+ (Kind::Java | Kind::Maven | Kind::Gradle | Kind::JvmTool, _) => {+ if let Some(args) = args+ && is_utf8(encoding)+ && !sets(&tool_options, &[FILE_ENCODING])+ {+ match kind {+ Kind::Maven => out.args = spring_boot_file_encoding(args),+ Kind::Gradle => out.gradle_init_script = true,+ _ => {}+ }+ }if !sets(&tool_options, STD_PROPERTIES) {let added = options(STD_PROPERTIES, encoding).join(" ");let value = match tool_options.trim() {@@ -214,6 +251,26 @@ fn fix_kind(out}+fn spring_boot_file_encoding(args: &[String]) -> Option<Vec<String>> {+ if !args.iter().any(|a| a == "spring-boot:run" || (a.contains(":spring-boot-maven-plugin:") && a.ends_with(":run")))+ {+ return None;+ }+ let option = format!("-D{FILE_ENCODING}=UTF-8");+ let mut out = args.to_vec();+ match out.iter_mut().rfind(|a| a.starts_with(SPRING_BOOT_JVM_ARGS)) {+ Some(own) if sets(own, &[FILE_ENCODING]) => return None,+ Some(own) => {+ if own.len() > SPRING_BOOT_JVM_ARGS.len() {+ own.push(' ');+ }+ own.push_str(&option);+ }+ None => out.push(format!("{SPRING_BOOT_JVM_ARGS}{option}")),+ }+ Some(out)+}+/// `vmArgs` of a launch by java-debug, which decodes the JVM's output as `encoding`/// (its launch attribute, UTF-8 when unset). java-debug sets `file.encoding` only/// when that attribute is nonblank; use the same defaults and user overrides as [`fix`].@@ -435,6 +492,64 @@ mod tests {assert_eq!(run("python3", &[], &[], "GBK", false).env, [("PYTHONIOENCODING".to_owned(), "GBK".to_owned())]);}+ #[test]+ fn spring_boot_run_forks_get_a_utf8_default_charset() {+ let boot = |args: &[&str], env: &[(&str, &str)]| run("mvn.cmd", args, env, "UTF-8", true).args;+ let utf8 = "-Dspring-boot.run.jvmArguments=-Dfile.encoding=UTF-8";+ assert_eq!(boot(&["spring-boot:run"], &[]).unwrap(), ["spring-boot:run", utf8]);+ let plugin = "org.springframework.boot:spring-boot-maven-plugin:3.2.0:run";+ assert_eq!(boot(&["-pl", "app", plugin], &[]).unwrap(), ["-pl", "app", plugin, utf8]);+ // The user's VM options are kept; their own `file.encoding` wins.+ assert_eq!(+ boot(&["spring-boot:run", "-Dspring-boot.run.jvmArguments=-Xmx1g \"-Da=b c\""], &[]).unwrap(),+ ["spring-boot:run", "-Dspring-boot.run.jvmArguments=-Xmx1g \"-Da=b c\" -Dfile.encoding=UTF-8"]+ );+ assert_eq!(boot(&["spring-boot:run", "-Dspring-boot.run.jvmArguments="], &[]).unwrap()[1], utf8);+ assert!(boot(&["spring-boot:run", "-Dspring-boot.run.jvmArguments=-Dfile.encoding=GBK"], &[]).is_none());+ assert!(boot(&["spring-boot:run"], &[(TOOL_OPTIONS, "-Dfile.encoding=GBK")]).is_none());+ // Other goals and tools, other consoles, and other platforms are left alone.+ assert!(boot(&["package"], &[]).is_none());+ assert!(run("mvn", &["spring-boot:run"], &[], "GBK", true).args.is_none());+ assert!(run("mvn", &["spring-boot:run"], &[], "UTF-8", false).args.is_none());+ }++ #[test]+ fn forked_application_jvms_get_a_utf8_default_charset() {+ // Reported: a Spring Boot app run by the build on Chinese Windows (JDK 8–17, GBK default).+ for (tool, args) in [+ ("C:\\p\\gradlew.bat", &["bootRun"][..]),+ ("gradle", &[":app:run"]),+ ("mvnw.cmd", &["spring-boot:run"]),+ ("mvnd", &["org.springframework.boot:spring-boot-maven-plugin:2.7.18:run"]),+ ] {+ let f = run(tool, args, &[], "UTF-8", true);+ let gradle = tool.contains("gradle");+ assert_eq!(f.gradle_init_script, gradle, "{tool}");+ assert_eq!(f.args.is_some(), !gradle, "{tool}");+ // The build tool's own JVM keeps its default charset.+ assert!(!tool_env(&f).unwrap().contains("file.encoding"), "{tool}");+ // The user's choice, a GBK console and other platforms are left alone.+ let own = run(tool, args, &[(TOOL_OPTIONS, "-Dfile.encoding=GBK")], "UTF-8", true);+ assert!(!own.gradle_init_script && own.args.is_none(), "{tool}");+ let gbk = run(tool, args, &[], "GBK", true);+ assert!(!gbk.gradle_init_script && gbk.args.is_none(), "{tool}");+ assert_eq!(run(tool, args, &[], "UTF-8", false), EncodingFix::default(), "{tool}");+ }+ // Shell command lines can't take arguments; other JVM tools fork no application.+ assert!(!fix_command_line("gradlew bootRun", &BTreeMap::new(), |_| None, "UTF-8", true).gradle_init_script);+ let sbt = run("sbt", &["run"], &[], "UTF-8", true);+ assert!(!sbt.gradle_init_script && sbt.args.is_none());+ }++ #[test]+ fn gradle_script_respects_the_builds_own_file_encoding() {+ let s = GRADLE_FILE_ENCODING_SCRIPT;+ assert!(s.contains("tasks.withType(JavaExec).configureEach"), "{s}");+ assert!(s.contains("defaultCharacterEncoding = 'UTF-8'"), "{s}");+ assert!(!s.contains("doFirst"), "the build must be able to override the default: {s}");+ assert!(!s.contains("withType(Test)") && !s.contains("JavaCompile"), "{s}");+ }+#[test]fn shell_command_lines_get_variables_from_their_first_word() {let line = |l: &str| fix_command_line(l, &BTreeMap::new(), |_| None, "UTF-8", true);diff --git a/crates/ide-run/src/gradle_jvm.rs b/crates/ide-run/src/gradle_jvm.rsindex 0734a851c..cae12a3fd 100644--- a/crates/ide-run/src/gradle_jvm.rs+++ b/crates/ide-run/src/gradle_jvm.rs@@ -41,17 +41,22 @@ pub fn default_dir() -> PathBuf {/// Writes the script for `jvm_args` under `dir` (named by its content, so launches share/// it and nothing needs deleting) and returns its path.pub fn write_init_script(dir: &Path, jvm_args: &[String]) -> std::io::Result<PathBuf> {+ write_script(dir, "jvm-args", &init_script(jvm_args))+}++/// Writes the init script `text` under `dir` as `<prefix>-<hash>.init.gradle` (written+/// once per content, so launches share it) and returns its path.+pub fn write_script(dir: &Path, prefix: &str, text: &str) -> std::io::Result<PathBuf> {use std::hash::{Hash, Hasher};- let text = init_script(jvm_args);let mut h = std::collections::hash_map::DefaultHasher::new();text.hash(&mut h);- let file = dir.join(format!("jvm-args-{:016x}.init.gradle", h.finish()));+ let file = dir.join(format!("{prefix}-{:016x}.init.gradle", h.finish()));if std::fs::read_to_string(&file).is_ok_and(|t| t == text) {return Ok(file);}std::fs::create_dir_all(dir)?;let tmp = file.with_extension(format!("{}.tmp", std::process::id()));- std::fs::write(&tmp, &text)?;+ std::fs::write(&tmp, text)?;std::fs::rename(&tmp, &file).inspect_err(|_| {let _ = std::fs::remove_file(&tmp);})?;diff --git a/crates/ide-run/src/process.rs b/crates/ide-run/src/process.rsindex 969114d23..17779e3ba 100644--- a/crates/ide-run/src/process.rs+++ b/crates/ide-run/src/process.rs@@ -195,8 +195,21 @@ fn match_console_encoding(output_encoding::fix(&program, &inv.args, &env.vars, inherited, encoding, cfg!(windows))};env.vars.extend(fix.env);- if !fix.java_args.is_empty() && !inv.raw_args {- inv.args.splice(0..0, fix.java_args);+ let mut prepend = fix.java_args;+ if fix.gradle_init_script {+ match crate::gradle_jvm::write_script(+ &crate::gradle_jvm::default_dir(),+ "file-encoding",+ output_encoding::GRADLE_FILE_ENCODING_SCRIPT,+ ) {+ Ok(script) => prepend.extend(["--init-script".to_owned(), script.to_string_lossy().into_owned()]),+ Err(e) => tracing::warn!("cannot write the Gradle file.encoding init script: {e}"),+ }+ }+ let changed = fix.args.is_some() || !prepend.is_empty();+ if changed && !inv.raw_args {+ inv.args = fix.args.unwrap_or_else(|| std::mem::take(&mut inv.args));+ inv.args.splice(0..0, prepend);let mut display = quote(config.command.trim());for a in &inv.args {display.push(' ');