Support for command wrapping ("aliases")

Add the --wraps option to 'complete' and 'function'. This allows a
command to (recursively) inherit the completions of a wrapped command.
Fixes fish-shell#393.

When evaluating a completion, we inspect the entire "wrap chain" for a
command, i.e. we follow the sequence of wrapping until we either hit a
loop (which we silently ignore) or the end of the chain. We then
evaluate completions as if the wrapping command were substituted with
the wrapped command. Currently this only works for commands, i.e.
'complete --command gco --wraps git\ checkout' won't work (that would
seem to encroaching on abbreviations anyways). It might be useful to
show an error message for that case.

The commandline builtin reflects the commandline with the wrapped
command substituted in, so e.g. git completions (which inspect the
command line) will just work. This sort of command line munging is
also performed by 'complete -C' so it's not totally without precedent.

'alias will also now mark its generated function as wrapping the
'target.

Author: ridiculousfish

builtin.cpp

@@ -1809,6 +1809,8 @@ int define_function(parser_t &parser, const wcstring_list_t &c_args, const wcstr
     bool shadows = true;
 
     woptind=0;
+    
+    wcstring_list_t wrap_targets;
 
     const struct woption long_options[] =
     {
@@ -1818,6 +1820,7 @@ int define_function(parser_t &parser, const wcstring_list_t &c_args, const wcstr
         { L"on-process-exit", required_argument, 0, 'p' },
         { L"on-variable", required_argument, 0, 'v' },
         { L"on-event", required_argument, 0, 'e' },
+        { L"wraps", required_argument, 0, 'w' },
         { L"help", no_argument, 0, 'h' },
         { L"argument-names", no_argument, 0, 'a' },
         { L"no-scope-shadowing", no_argument, 0, 'S' },
@@ -1979,6 +1982,10 @@ int define_function(parser_t &parser, const wcstring_list_t &c_args, const wcstr
             case 'S':
                 shadows = 0;
                 break;
+                
+            case 'w':
+                wrap_targets.push_back(woptarg);
+                break;
 
             case 'h':
                 builtin_print_help(parser, argv[0], stdout_buffer);
@@ -2086,6 +2093,12 @@ int define_function(parser_t &parser, const wcstring_list_t &c_args, const wcstr
         d.definition = contents.c_str();
 
         function_add(d, parser, definition_line_offset);
+        
+        // Handle wrap targets
+        for (size_t w=0; w < wrap_targets.size(); w++)
+        {
+            complete_add_wrapper(name, wrap_targets.at(w));
+        }
     }
 
     return res;

builtin.h

@@ -164,12 +164,25 @@ void builtin_pop_io(parser_t &parser);
 wcstring builtin_get_desc(const wcstring &b);
 
 
-/**
-   Slightly kludgy function used with 'complete -C' in order to make
-   the commandline builtin operate on the string to complete instead
-   of operating on whatever is to be completed.
-*/
-const wchar_t *builtin_complete_get_temporary_buffer();
+
+/** Support for setting and removing transient command lines.
+    This is used by 'complete -C' in order to make
+    the commandline builtin operate on the string to complete instead
+    of operating on whatever is to be completed. It's also used by
+    completion wrappers, to allow a command to appear as the command
+    being wrapped for the purposes of completion.
+    
+    Instantiating an instance of builtin_commandline_scoped_transient_t
+    pushes the command as the new transient commandline. The destructor removes it.
+    It will assert if construction/destruction does not happen in a stack-like (LIFO) order.
+*/
+class builtin_commandline_scoped_transient_t
+{
+    size_t token;
+    public:
+    builtin_commandline_scoped_transient_t(const wcstring &cmd);
+    ~builtin_commandline_scoped_transient_t();
+};
 
 
 /**

builtin_commandline.cpp

@@ -79,6 +79,51 @@ static size_t get_cursor_pos()
     return current_cursor_pos;
 }
 
+static pthread_mutex_t transient_commandline_lock = PTHREAD_MUTEX_INITIALIZER;
+static wcstring_list_t *get_transient_stack()
+{
+    ASSERT_IS_MAIN_THREAD();
+    ASSERT_IS_LOCKED(transient_commandline_lock);
+    // A pointer is a little more efficient than an object as a static because we can elide the thread-safe initialization
+    static wcstring_list_t *result = NULL;
+    if (! result)
+    {
+        result = new wcstring_list_t();
+    }
+    return result;
+}
+
+static bool get_top_transient(wcstring *out_result)
+{
+    ASSERT_IS_MAIN_THREAD();
+    bool result = false;
+    scoped_lock locker(transient_commandline_lock);
+    const wcstring_list_t *stack = get_transient_stack();
+    if (! stack->empty())
+    {
+        out_result->assign(stack->back());
+        result = true;
+    }
+    return result;
+}
+
+builtin_commandline_scoped_transient_t::builtin_commandline_scoped_transient_t(const wcstring &cmd)
+{
+    ASSERT_IS_MAIN_THREAD();
+    scoped_lock locker(transient_commandline_lock);
+    wcstring_list_t *stack = get_transient_stack();
+    stack->push_back(cmd);
+    this->token = stack->size();
+}
+
+builtin_commandline_scoped_transient_t::~builtin_commandline_scoped_transient_t()
+{
+    ASSERT_IS_MAIN_THREAD();
+    scoped_lock locker(transient_commandline_lock);
+    wcstring_list_t *stack = get_transient_stack();
+    assert(this->token == stack->size());
+    stack->pop_back();
+}
 
 /**
    Replace/append/insert the selection with/at/after the specified string.
@@ -216,11 +261,15 @@ static int builtin_commandline(parser_t &parser, wchar_t **argv)
     int search_mode = 0;
     int paging_mode = 0;
     const wchar_t *begin = NULL, *end = NULL;
-
-    current_buffer = (wchar_t *)builtin_complete_get_temporary_buffer();
-    if (current_buffer)
+    
+    scoped_push<const wchar_t *> saved_current_buffer(&current_buffer);
+    scoped_push<size_t> saved_current_cursor_pos(&current_cursor_pos);
+    
+    wcstring transient_commandline;
+    if (get_top_transient(&transient_commandline))
     {
-        current_cursor_pos = wcslen(current_buffer);
+        current_buffer = transient_commandline.c_str();
+        current_cursor_pos = transient_commandline.size();
     }
     else
     {

builtin_complete.cpp

@@ -24,12 +24,6 @@ Functions used for implementing the complete builtin.
 #include "parser.h"
 #include "reader.h"
 
-
-/**
-   Internal storage for the builtin_complete_get_temporary_buffer() function.
-*/
-static const wchar_t *temporary_buffer;
-
 /*
   builtin_complete_* are a set of rather silly looping functions that
   make sure that all the proper combinations of complete_add or
@@ -270,13 +264,6 @@ static void  builtin_complete_remove(const wcstring_list_t &cmd,
 
 }
 
-
-const wchar_t *builtin_complete_get_temporary_buffer()
-{
-    ASSERT_IS_MAIN_THREAD();
-    return temporary_buffer;
-}
-
 /**
    The complete builtin. Used for specifying programmable
    tab-completions. Calls the functions in complete.c for any heavy
@@ -300,6 +287,7 @@ static int builtin_complete(parser_t &parser, wchar_t **argv)
 
     wcstring_list_t cmd;
     wcstring_list_t path;
+    wcstring_list_t wrap_targets;
 
     static int recursion_level=0;
 
@@ -326,6 +314,7 @@ static int builtin_complete(parser_t &parser, wchar_t **argv)
             { L"unauthoritative", no_argument, 0, 'u' },
             { L"authoritative", no_argument, 0, 'A' },
             { L"condition", required_argument, 0, 'n' },
+            { L"wraps", required_argument, 0, 'w' },
             { L"do-complete", optional_argument, 0, 'C' },
             { L"help", no_argument, 0, 'h' },
             { 0, 0, 0, 0 }
@@ -422,6 +411,10 @@ static int builtin_complete(parser_t &parser, wchar_t **argv)
             case 'n':
                 condition = woptarg;
                 break;
+                
+            case 'w':
+                wrap_targets.push_back(woptarg);
+                break;
 
             case 'C':
                 do_complete = true;
@@ -495,9 +488,9 @@ static int builtin_complete(parser_t &parser, wchar_t **argv)
             const wchar_t *token;
 
             parse_util_token_extent(do_complete_param.c_str(), do_complete_param.size(), &token, 0, 0, 0);
-
-            const wchar_t *prev_temporary_buffer = temporary_buffer;
-            temporary_buffer = do_complete_param.c_str();
+            
+            /* Create a scoped transient command line, so that bulitin_commandline will see our argument, not the reader buffer */
+            builtin_commandline_scoped_transient_t temp_buffer(do_complete_param);
 
             if (recursion_level < 1)
             {
@@ -536,9 +529,6 @@ static int builtin_complete(parser_t &parser, wchar_t **argv)
 
                 recursion_level--;
             }
-
-            temporary_buffer = prev_temporary_buffer;
-
         }
         else if (woptind != argc)
         {
@@ -558,14 +548,15 @@ static int builtin_complete(parser_t &parser, wchar_t **argv)
         else
         {
             int flags = COMPLETE_AUTO_SPACE;
-
+        
             if (remove)
             {
                 builtin_complete_remove(cmd,
                                         path,
                                         short_opt.c_str(),
                                         gnu_opt,
                                         old_opt);
+                
             }
             else
             {
@@ -581,7 +572,18 @@ static int builtin_complete(parser_t &parser, wchar_t **argv)
                                      desc,
                                      flags);
             }
-
+            
+            // Handle wrap targets (probably empty)
+            // We only wrap commands, not paths
+            for (size_t w=0; w < wrap_targets.size(); w++)
+            {
+                const wcstring &wrap_target = wrap_targets.at(w);
+                for (size_t i=0; i < cmd.size(); i++)
+                {
+                    
+                    (remove ? complete_remove_wrapper : complete_add_wrapper)(cmd.at(i), wrap_target);
+                }
+            }
         }
     }