[Bash-autocompletion] Auto complete cc1 options if -cc1 is specified

[yamaguchi]

Summary

We don't want to autocomplete flags whose Flags class has NoDriverOption when argv[1] is not -cc1.

Another idea for this implementation is to make --autocomplete a cc1
option and handle it in clang Frontend, by porting --autocomplete
handler from Driver to Frontend, so that we can handle Driver options
and CC1 options in unified manner.

[yamaguchi]

Update patch.

[teemperor]

Two thought from me on this:

1. I think we want to support completing both -cc1 and normal driver invocation. Most people use the driver, but for example during debugging people use the cc1 version, so both are valid use cases. I just saw we actually have the completion code in the Driver, so what do you think about moving the code to the Frontend part and call it from the Driver/Frontend part?

2. I think it makes the most sense if we complete cc1 options but return "-Xclang OPTION" when we encounter a cc1 option from the Driver (because it's the least intrusive thing to do and the cc1 options are the ones everyone forgets about :) ).

[yamaguchi]

@teemperor

I think we want to support completing both -cc1 and normal driver invocation. Most people use the driver, but for example during debugging people use the cc1 version, so both are valid use cases. I just saw we actually have the completion code in the Driver, so what do you think about moving the code to the Frontend part and call it from the Driver/Frontend part?

I'm not sure what you refer to by I just saw we actually have the completion code in the Driver. We are already auto completing both cc1 options and driver options, right?
I'm sorry but I don't understand your main point. What am I missing?

I think it makes the most sense if we complete cc1 options but return "-Xclang OPTION" when we encounter a cc1 option from the Driver (because it's the least intrusive thing to do and the cc1 options are the ones everyone forgets about :) ).

What about completing cc1 options only when -cc1 is passed or -Xclang is passed before current input?

[teemperor]

I'm not sure what you refer to by I just saw we actually have the completion code in the Driver. We are already auto completing both cc1 options and driver options, right?

Woops, I misread the code there. Never mind!

What about completing cc1 options only when -cc1 is passed or -Xclang is passed before current input?

That actually sounds like the best solution, let's go with that!

[yamaguchi]

Update diff. Autocomplete cc1 flags when argv[1] is -cc1 or previous flag is -Xclang.

[yamaguchi]

Update code comments.

[compnerd]

clang/lib/Driver/Driver.cpp

1236

Typo: ther -> the.

clang/utils/bash-autocomplete.sh

16

prefix may be a better term?

[yamaguchi]

Fixed typo.

[yamaguchi]

clang/utils/bash-autocomplete.sh

16

Thanks for reviewing!
$arg has string like -stdlib=,plat, so prefix seems not very appropriate?

clang/lib/Driver/Driver.cpp

bool Driver::HandleImmediateArgs(const Compilation &C) {
   }
 
   if (Arg *A = C.getArgs().getLastArg(options::OPT_autocomplete)) {
     // Print out all options that start with a given argument. This is used for
     // shell autocompletion.
     StringRef PassedFlags = A->getValue();
     std::vector<std::string> SuggestedCompletions;
 
+    unsigned short DisableFlags = options::NoDriverOption | options::Unsupported | options::Ignored;
+    // We want to show cc1-only options only when clang is invoked as "clang -cc1".
+    // When clang is invoked as "clang -cc1", we add "#" to ther beginning of an --autocomplete
+    // option so that the clang driver can distinguish whether it is requested to show cc1-only options or not.
+    if (PassedFlags[0] == '#') {
+      DisableFlags &= ~options::NoDriverOption;
+      PassedFlags = PassedFlags.substr(1);
+    }
+
     if (PassedFlags.find(',') == StringRef::npos) {
       // If the flag is in the form of "--autocomplete=-foo",
       // we were requested to print out all option names that start with "-foo".
       // For example, "--autocomplete=-fsyn" is expanded to "-fsyntax-only".
-      SuggestedCompletions = Opts->findByPrefix(PassedFlags);
+      SuggestedCompletions = Opts->findByPrefix(PassedFlags, DisableFlags);
     } else {
       // If the flag is in the form of "--autocomplete=foo,bar", we were
       // requested to print out all option values for "-foo" that start with
       // "bar". For example,
       // "--autocomplete=-stdlib=,l" is expanded to "libc++" and "libstdc++".
       StringRef Option, Arg;
       std::tie(Option, Arg) = PassedFlags.split(',');
       SuggestedCompletions = Opts->suggestValueCompletions(Option, Arg);

clang/test/Driver/autocomplete.c

 // RUN: %clang --autocomplete=-fvisibility=, | FileCheck %s -check-prefix=FVISIBILITYALL
 // FVISIBILITYALL: default hidden
 // RUN: %clang --autocomplete=-mfloat-abi=, | FileCheck %s -check-prefix=MFLOATABIALL
 // MFLOATABIALL: hard soft softfp
 // RUN: %clang --autocomplete=-mthread-model, | FileCheck %s -check-prefix=MTHREADMODELALL
 // MTHREADMODELALL: posix single
 // RUN: %clang --autocomplete=-mrelocation-model, | FileCheck %s -check-prefix=MRELOCMODELALL
 // MRELOCMODELALL: dynamic-no-pic pic ropi ropi-rwpi rwpi static
+// RUN: %clang --autocomplete=-mrelocation-mode | FileCheck %s -check-prefix=MRELOCMODEL_CLANG
+// MRELOCMODEL_CLANG-NOT: -mrelocation-model
+// RUN: %clang --autocomplete=#-mrelocation-mode | FileCheck %s -check-prefix=MRELOCMODEL_CC1
+// MRELOCMODEL_CC1: -mrelocation-model

clang/utils/bash-autocomplete.sh

 # Please add "source /path/to/bash-autocomplete.sh" to your .bashrc to use this.
 _clang()
 {
   local cur prev words cword arg flags
   _init_completion -n : || return
 
   # bash always separates '=' as a token even if there's no space before/after '='.
   # On the other hand, '=' is just a regular character for clang options that
   # contain '='. For example, "-stdlib=" is defined as is, instead of "-stdlib" and "=".
   # So, we need to partially undo bash tokenization here for integrity.
   local w1="${COMP_WORDS[$cword - 1]}"
   local w2="${COMP_WORDS[$cword - 2]}"
+  # Clang want to know if -cc1 option is specified or not, because we don't want to show
+  # cc1 options otherwise.
+  if [[ "${COMP_WORDS[1]}" == "-cc1" || "$w1" == "-Xclang" ]]; then
+    arg="#"
+  fi
   if [[ "$cur" == -* ]]; then
     # -foo<tab>
-    arg="$cur"
+    arg="$arg$cur"
   elif [[ "$w1" == -*  && "$cur" == '=' ]]; then
     # -foo=<tab>
-    arg="$w1=,"
+    arg="$arg$w1=,"
   elif [[ "$w1" == -* ]]; then
     # -foo <tab> or -foo bar<tab>
-    arg="$w1,$cur"
+    arg="$arg$w1,$cur"
   elif [[ "$w2" == -* && "$w1" == '=' ]]; then
     # -foo=bar<tab>
-    arg="$w2=,$cur"
+    arg="$arg$w2=,$cur"
   fi
 
   flags=$( "${COMP_WORDS[0]}" --autocomplete="$arg" 2>/dev/null )
   # If clang is old that it does not support --autocomplete,
   # fall back to the filename completion.
   if [[ "$?" != 0 ]]; then
     _filedir
     return

llvm/include/llvm/Option/OptTable.h

std::vector<std::string> suggestValueCompletions(StringRef Option,
                                                    StringRef Arg) const;
 
   /// Find flags from OptTable which starts with Cur.
   ///
   /// \param [in] Cur - String prefix that all returned flags need
   //  to start with.
   ///
   /// \return The vector of flags which start with Cur.
-  std::vector<std::string> findByPrefix(StringRef Cur) const;
+  std::vector<std::string> findByPrefix(StringRef Cur,
+                                        unsigned short DisableFlags) const;
 
   /// \brief Parse a single argument; returning the new argument and
   /// updating Index.
   ///
   /// \param [in,out] Index - The current parsing position in the argument
   /// string list; on return this will be the index of the next argument
   /// string to parse.
   /// \param [in] FlagsToInclude - Only parse options with any of these flags.

llvm/lib/Option/OptTable.cpp

for (const Info &In : OptionInfos.slice(FirstSearchableIndex)) {
     for (StringRef Val : Candidates)
       if (Val.startswith(Arg))
         Result.push_back(Val);
     return Result;
   }
   return {};
 }
 
-std::vector<std::string> OptTable::findByPrefix(StringRef Cur) const {
+std::vector<std::string>
+OptTable::findByPrefix(StringRef Cur, unsigned short DisableFlags) const {
   std::vector<std::string> Ret;
   for (const Info &In : OptionInfos.slice(FirstSearchableIndex)) {
     if (!In.Prefixes)
       continue;
+    if (In.Flags & DisableFlags)
+      continue;
+
     for (int I = 0; In.Prefixes[I]; I++) {
       std::string S = std::string(In.Prefixes[I]) + std::string(In.Name);
       if (StringRef(S).startswith(Cur))
         Ret.push_back(S);
     }
   }
   return Ret;
 }