implement properly

Author: dsherret

src/parser.rs

@@ -753,30 +753,35 @@ fn parse_word_parts(
     or7(
       parse_special_shell_var,
       parse_escaped_dollar_sign,
+      parse_escaped_char('~'),
       parse_escaped_char('`'),
       parse_escaped_char('"'),
       parse_escaped_char('('),
-      parse_escaped_char(')'),
-      if_true(parse_escaped_char('\''), move |_| {
-        mode == ParseWordPartsMode::DoubleQuotes
-      }),
+      or(
+        parse_escaped_char(')'),
+        if_true(parse_escaped_char('\''), move |_| {
+          mode == ParseWordPartsMode::DoubleQuotes
+        }),
+      )
     )
   }
 
   move |input| {
     enum PendingPart<'a> {
       Char(char),
       Variable(&'a str),
+      Tilde,
       Command(SequentialList),
       Parts(Vec<WordPart>),
     }
 
     let (input, parts) = many0(or7(
-      or(
+      or3(
         map(tag("$?"), |_| PendingPart::Variable("?")),
         map(first_escaped_char(mode), PendingPart::Char),
+        map(parse_command_substitution, PendingPart::Command),
       ),
-      map(parse_command_substitution, PendingPart::Command),
+      map(ch('~'), |_| PendingPart::Tilde),
       map(preceded(ch('$'), parse_env_var_name), PendingPart::Variable),
       |input| {
         let (_, _) = ch('`')(input)?;
@@ -796,7 +801,7 @@ fn parse_word_parts(
         if_true(next_char, |&c| match mode {
           ParseWordPartsMode::DoubleQuotes => c != '"',
           ParseWordPartsMode::Unquoted => {
-            !c.is_whitespace() && !"(){}<>|&;\"'".contains(c)
+            !c.is_whitespace() && !"~(){}<>|&;\"'".contains(c)
           }
         }),
         PendingPart::Char,
@@ -823,6 +828,7 @@ fn parse_word_parts(
             result.push(WordPart::Text(c.to_string()));
           }
         }
+        PendingPart::Tilde => result.push(WordPart::Tilde),
         PendingPart::Command(s) => result.push(WordPart::Command(s)),
         PendingPart::Variable(v) => {
           result.push(WordPart::Variable(v.to_string()))

src/shell/execute.rs

@@ -1,7 +1,5 @@
 // Copyright 2018-2024 the Deno authors. MIT license.
 
-use std::borrow::Cow;
-use std::cell::OnceCell;
 use std::collections::HashMap;
 use std::ffi::OsStr;
 use std::ffi::OsString;
@@ -752,8 +750,6 @@ pub enum EvaluateWordTextError {
   NotUtf8Pattern { part: OsString },
   #[error("glob: no matches found '{}'", pattern)]
   NoFilesMatched { pattern: String },
-  #[error("tilde expansion requires valid utf-8 (text: '{}')", lossy_text)]
-  TildeExpansionInvalidUtf8 { lossy_text: String },
   #[error("invalid utf-8: {}", err)]
   InvalidUtf8 {
     #[from]
@@ -800,13 +796,9 @@ fn evaluate_word_parts(
 
   fn evaluate_word_text(
     state: &ShellState,
-    mut text_parts: Vec<TextPart>,
+    text_parts: Vec<TextPart>,
     is_quoted: bool,
   ) -> Result<Vec<OsString>, EvaluateWordTextError> {
-    if !is_quoted {
-      tilde_expand_text_parts(state, &mut text_parts)?;
-    }
-
     if !is_quoted
       && text_parts
         .iter()
@@ -894,57 +886,6 @@ fn evaluate_word_parts(
     }
   }
 
-  fn tilde_expand_text_parts(
-    state: &ShellState,
-    text_parts: &mut Vec<TextPart>,
-  ) -> Result<(), EvaluateWordTextError> {
-      let lazy_home_dir: OnceCell<PathBuf> = OnceCell::new();
-      // tilde expansion
-      for part in text_parts {
-        match part {
-            TextPart::Text(os_string) => {
-              let text = os_string.to_string_lossy();
-              let mut was_last_escape = false;
-              let mut new_text = OsString::new();
-              let mut last_index = 0;
-              for (index, c) in text.char_indices() {
-                match c {
-                  '\\' => {
-                    was_last_escape = true;
-                  }
-                  '~' if was_last_escape => {
-                    new_text.push(&text[last_index..index - 1]);
-                    new_text.push("~");
-                    last_index = index + 1;
-                  }
-                  '~' if !was_last_escape => {
-                    if let Cow::Owned(text) = text {
-                      return Err(EvaluateWordTextError::TildeExpansionInvalidUtf8 { lossy_text: text });
-                    }
-                    new_text.push(&text[last_index..index]);
-                    last_index = index + 1;
-                    // push the home dir
-                    let home_dir = lazy_home_dir.get_or_init(||sys_traits::impls::real_home_dir_with_env(state).unwrap_or_else(|| PathBuf::from("~")));
-                    new_text.push(home_dir);
-                  }
-                  _ => {
-                    was_last_escape = false;
-                  }
-                }
-              }
-              if last_index > 0 {
-                new_text.push(&text[last_index..]);
-                *os_string = new_text;
-              }
-            },
-            TextPart::Quoted(_) => {
-              // do not expand in quotes
-            },
-        }
-      }
-      Ok(())
-    }
-
   fn evaluate_word_parts_inner(
     parts: Vec<WordPart>,
     is_quoted: bool,
@@ -963,6 +904,9 @@ fn evaluate_word_parts(
             None
           }
           WordPart::Variable(name) => state.get_var(OsStr::new(&name)).cloned(),
+          WordPart::Tilde => {
+            sys_traits::impls::real_home_dir_with_env(state).map(|s| s.into_os_string())
+          }
           WordPart::Command(list) => Some(
             evaluate_command_substitution(
               list,