This patch changes the way command line options are printed out.

[tra]

Summary

• If a flag option has an alias, --help will print it next to the option. E.g: --preprocess, which is an alias for -E will be printed as: --preprocess | -E

• Optionally allow printing out command line options that don't have associated HelpText. This is used by Clang's --help-hidden-all I'm adding in a separate patch.

[tra]

Clang side of the changes is in D7362

include/llvm/Option/OptTable.h

public:
   /// \brief Render the help text for an option table.
   ///
   /// \param OS - The stream to write the help text to.
   /// \param Name - The name to use in the usage line.
   /// \param Title - The title to use in the usage line.
   /// \param FlagsToInclude - If non-zero, only include options with any
   ///                         of these flags set.
   /// \param FlagsToExclude - Exclude options with any of these flags set.
-  void PrintHelp(raw_ostream &OS, const char *Name,
-                 const char *Title, unsigned FlagsToInclude,
-                 unsigned FlagsToExclude) const;
+  /// \param PrintUndocumented - Print options that don't have any help.
+  void PrintHelp(raw_ostream &OS, const char *Name, const char *Title,
+                 unsigned FlagsToInclude, unsigned FlagsToExclude,
+                 bool PrintUndocumented = false) const;
 
   void PrintHelp(raw_ostream &OS, const char *Name,
                   const char *Title, bool ShowHidden = false) const;
 };
 } // end namespace opt
 } // end namespace llvm
 
 #endif

lib/Option/OptTable.cpp

while (Index < End) {
     }
 
     Args->append(A);
   }
 
   return Args;
 }
 
+static std::string getOptionAlias(const OptTable &Opts, OptSpecifier Id) {
+  const Option O = Opts.getOption(Id);
+  std::string Name;
+
+  if (O.getAlias().isValid()) {
+    Name += O.getAlias().getPrefixedName();
+    if (O.getAliasArgs()) {
+      const char *Val = O.getAliasArgs();
+      const char *ArgSeparator = "";
+      while (*Val != '\0') {
+        Name += ArgSeparator;
+        Name += Val;
+        // Move past the '\0' to the next argument.
+        Val += strlen(Val) + 1;
+        ArgSeparator = " ";
+      }
+    }
+  }
+  return Name;
+}
+
 static std::string getOptionHelpName(const OptTable &Opts, OptSpecifier Id) {
   const Option O = Opts.getOption(Id);
   std::string Name = O.getPrefixedName();
 
   // Add metavar, if used.
   switch (O.getKind()) {
   case Option::GroupClass: case Option::InputClass: case Option::UnknownClass:
     llvm_unreachable("Invalid option with help text.");
 
   case Option::MultiArgClass:
     if (const char *MetaVarName = Opts.getOptionMetaVar(Id)) {
       // For MultiArgs, metavar is full list of all argument names.
       Name += ' ';
       Name += MetaVarName;
     }
     else {
       // For MultiArgs<N>, if metavar not supplied, print <value> N times.
       for (unsigned i=0, e=O.getNumArgs(); i< e; ++i) {
         Name += " <value>";
       }
     }
     break;
 
   case Option::FlagClass:
+    if (O.getAlias().isValid()) {
+      const std::string Alias = getOptionAlias(Opts, Id);
+      assert(!Alias.empty() && "Valid but empty alias.");
+      Name += " | ";
+      Name += Alias;
+    }
     break;
 
   case Option::SeparateClass: case Option::JoinedOrSeparateClass:
   case Option::RemainingArgsClass:
     Name += ' ';
     // FALLTHROUGH
   case Option::JoinedClass: case Option::CommaJoinedClass:
   case Option::JoinedAndSeparateClass:
static void PrintHelpOptionList(raw_ostream &OS, StringRef Title,
   }
 
   const unsigned InitialPad = 2;
   for (unsigned i = 0, e = OptionHelp.size(); i != e; ++i) {
     const std::string &Option = OptionHelp[i].first;
     int Pad = OptionFieldWidth - int(Option.size());
     OS.indent(InitialPad) << Option;
 
-    // Break on long option names.
+    // Break on long option names if there's a help string to print.
     if (Pad < 0) {
+      if (strlen(OptionHelp[i].second) > 0) {
         OS << "\n";
+      }
       Pad = OptionFieldWidth + InitialPad;
     }
     OS.indent(Pad + 1) << OptionHelp[i].second << '\n';
   }
 }
 
 static const char *getOptionHelpGroup(const OptTable &Opts, OptSpecifier Id) {
   unsigned GroupID = Opts.getOptionGroupID(Id);

 }
 
 void OptTable::PrintHelp(raw_ostream &OS, const char *Name, const char *Title,
                          bool ShowHidden) const {
   PrintHelp(OS, Name, Title, /*Include*/ 0, /*Exclude*/
             (ShowHidden ? 0 : HelpHidden));
 }
 
-
 void OptTable::PrintHelp(raw_ostream &OS, const char *Name, const char *Title,
-                         unsigned FlagsToInclude,
-                         unsigned FlagsToExclude) const {
+                         unsigned FlagsToInclude, unsigned FlagsToExclude,
+                         bool PrintUndocumented) const {
   OS << "OVERVIEW: " << Title << "\n";
   OS << '\n';
   OS << "USAGE: " << Name << " [options] <inputs>\n";
   OS << '\n';
 
   // Render help text into a map of group-name to a list of (option, help)
   // pairs.
   typedef std::map<std::string,
                  std::vector<std::pair<std::string, const char*> > > helpmap_ty;
   helpmap_ty GroupedOptionHelp;
 
   for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
     unsigned Id = i + 1;
 
     // FIXME: Split out option groups.
     if (getOptionKind(Id) == Option::GroupClass)
       continue;
 
     unsigned Flags = getInfo(Id).Flags;
     if (FlagsToInclude && !(Flags & FlagsToInclude))
       continue;
     if (Flags & FlagsToExclude)
       continue;
 
-    if (const char *Text = getOptionHelpText(Id)) {
+    const char *HelpText = getOptionHelpText(Id);
+
+    if (!HelpText && PrintUndocumented) {
+      switch (getOptionKind(Id)) {
+      case Option::GroupClass:
+      case Option::InputClass:
+      case Option::UnknownClass:
+        // These option kinds are not supposed to be printed even now.
+        break;
+      default:
+        // For other options without help, fake an empty help string.
+        HelpText = "";
+      }
+    }
+
+    if (HelpText) {
       const char *HelpGroup = getOptionHelpGroup(*this, Id);
       const std::string &OptName = getOptionHelpName(*this, Id);
-      GroupedOptionHelp[HelpGroup].push_back(std::make_pair(OptName, Text));
+      GroupedOptionHelp[HelpGroup].push_back(std::make_pair(OptName, HelpText));
     }
   }
 
   for (helpmap_ty::iterator it = GroupedOptionHelp .begin(),
          ie = GroupedOptionHelp.end(); it != ie; ++it) {
     if (it != GroupedOptionHelp .begin())
       OS << "\n";
     PrintHelpOptionList(OS, it->first, it->second);
   }
 
   OS.flush();
 }