[CodeCompletion][clangd] Clean __uglified parameter names in completion & hover

[sammccall]

Summary

Underscore-uglified identifiers are used in standard library implementations to
guard against collisions with macros, and they hurt readability considerably.
(Consider push_back(Tp_ &&__value) vs push_back(Tp value).
When we're describing an interface, the exact names of parameters are not
critical so we can drop these prefixes.

This patch adds a new PrintingPolicy flag that can applies this stripping
when recursively printing pieces of AST.
We set it in code completion/signature help, and in clangd's hover display.
All three features also do a bit of manual poking at names, so fix up those too.

Fixes https://github.com/clangd/clangd/issues/736

[hokein]

Agree that __ reserved names are ugly, but I'm not sure this is a great improvement.

I played around the patch locally, and found the new behavior being confused in some cases (mostly inconsistencies between deuglified places vs uglified places), and seems hard for readers to predict it:

• inconsistency with doc-comment which still uses the __ name (this seems hard to fix)

• the print type in hover still uses __name (maybe this is expected, or we could introduce a reserved field in hover, like template-type-param Tp (reserved))

• the deuglified behavior is triggered on (template/function) parameters, which means we have uglified name for void foo(_ReservedClass& abc) vs deuglified name for template<typename _ReservedClass> void foo(_ReservedClass& abc) (expanding the scope could fix that, but it doesn't seem something we want to do)

[sammccall]

In D116387#3230893, @hokein wrote:

Agree that __ reserved names are ugly, but I'm not sure this is a great improvement.

I played around the patch locally, and found the new behavior being confused in some cases (mostly inconsistencies between deuglified places vs uglified places), and seems hard for readers to predict it:

Agree, but I don't think it needs to be predictable, it's enough that the output can be understood.
(e.g. I never particularly noticed *which* identifiers in stdlib were ugly, just that the thing overall was hard to read).
i.e. if we remove the underscores half the time, that seems like a win.

• inconsistency with doc-comment which still uses the __ name (this seems hard to fix)

Yes :-( However I don't think a human reader is likely to be confused by this.

• the print type in hover still uses __name (maybe this is expected, or we could introduce a reserved field in hover, like template-type-param Tp (reserved))

This is an oversight, I'll fix this.

• the deuglified behavior is triggered on (template/function) parameters, which means we have uglified name for void foo(_ReservedClass& abc) vs deuglified name for template<typename _ReservedClass> void foo(_ReservedClass& abc) (expanding the scope could fix that, but it doesn't seem something we want to do)

This is deliberate: _ReservedClass is part of the API of foo, so renaming it is a semantic change.
I don't this change increases the amount of inconsistency: today we have`vector` vs push_back vs _ReservedClass vs _Tp.

[sammccall]

Fix printName

[sammccall]

Revert hover changes, only use for code complete

[hokein]

clang-tools-extra/clangd/Hover.cpp

65

IIUC, the code looks like we change the hover behavior as well, but I think our plan is to not change hover.

clang/lib/AST/DeclPrinter.cpp

889

nit: D->getIdentifier() seems redundant -- D->getName() has an isIdentifier() assertion, we should expect that we can always get identifier from D here.

1138

isa<TemplateTemplateParmDecl>(D) is redundant as line 1128 has checked it.

clang/lib/Basic/IdentifierTable.cpp

312

Not objecting the current approach -- an alternative is to incline this into getName by adding a parameter Deuglify to control the behavior.

Not sure it is much better, but it seem to save some boilerplate code like Policy.CleanUglifiedParameters ? II->deuglifiedName() : II->getName().

[sammccall]

clang-tools-extra/clangd/Hover.cpp

65

Oops, I messed up the revert. Fixed now!

clang/lib/AST/DeclPrinter.cpp

889

Sadly not: if D has no name (e.g. the param in void foo(int)) then isIdentifier() is true but getIdentifier() is nullptr :-(

This is a big trap in the API, but not one I can easily fix here.

clang/lib/Basic/IdentifierTable.cpp

312

Yeah, I was concerned about putting this in the way of a critical/central function.

If we were to do this maybe we should choose a spelling like getDeuglifiedName(bool Deuglify=true).

I'm not sure this is so much better, as it only helps some fraction of the callsites (not the ones that need to fall back to printing the whole DeclarationName instead, and not the one that want to use Policy.CleanUglifyParameters to short-circuit some other check instead)

[sammccall]

Fix hover revert.

clang-tools-extra/clangd/AST.h

 /// written in the code. E.g., passing 'using namespace ::std' will result in
 /// '::std'.
 std::string printUsingNamespaceName(const ASTContext &Ctx,
                                     const UsingDirectiveDecl &D);
 
 /// Prints unqualified name of the decl for the purpose of displaying it to the
 /// user. Anonymous decls return names of the form "(anonymous {kind})", e.g.
 /// "(anonymous struct)" or "(anonymous namespace)".
-std::string printName(const ASTContext &Ctx, const NamedDecl &ND);
+std::string printName(const ASTContext &Ctx, const NamedDecl &ND,
+                      const PrintingPolicy * = nullptr);
 
 /// Prints template arguments of a decl as written in the source code, including
 /// enclosing '<' and '>', e.g for a partial specialization like: template
 /// <typename U> struct Foo<int, U> will return '<int, U>'. Returns an empty
 /// string if decl is not a template specialization.
 std::string printTemplateSpecializationArgs(const NamedDecl &ND);
 
 /// Print the Objective-C method name, including the full container name, e.g.

clang-tools-extra/clangd/AST.cpp

std::string printUsingNamespaceName(const ASTContext &Ctx,
   llvm::raw_string_ostream Out(Name);
 
   if (auto *Qual = D.getQualifier())
     Qual->print(Out, PP);
   D.getNominatedNamespaceAsWritten()->printName(Out);
   return Out.str();
 }
 
-std::string printName(const ASTContext &Ctx, const NamedDecl &ND) {
+std::string printName(const ASTContext &Ctx, const NamedDecl &ND,
+                      const PrintingPolicy *BasePolicy) {
   std::string Name;
   llvm::raw_string_ostream Out(Name);
-  PrintingPolicy PP(Ctx.getLangOpts());
+  PrintingPolicy PP =
+      BasePolicy ? *BasePolicy : PrintingPolicy(Ctx.getLangOpts());
   // We don't consider a class template's args part of the constructor name.
   PP.SuppressTemplateArgsInCXXConstructors = true;
 
   // Handle 'using namespace'. They all have the same name - <using-directive>.
   if (auto *UD = llvm::dyn_cast<UsingDirectiveDecl>(&ND)) {
     Out << "using namespace ";
     if (auto *Qual = UD->getQualifier())
       Qual->print(Out, PP);
if (isa<EnumDecl>(ND))
       return "(anonymous enum)";
     return "(anonymous)";
   }
 
   // Print nested name qualifier if it was written in the source code.
   if (auto *Qualifier = getQualifierLoc(ND).getNestedNameSpecifier())
     Qualifier->print(Out, PP);
   // Print the name itself.
+  if (PP.CleanUglifiedParameters && ND.getIdentifier())
+    Out << ND.getIdentifier()->deuglifiedName();
+  else
     ND.getDeclName().print(Out, PP);
   // Print template arguments.
   Out << printTemplateSpecializationArgs(ND);
 
   return Out.str();
 }
 
 std::string printTemplateSpecializationArgs(const NamedDecl &ND) {
   std::string TemplateArgs;

clang-tools-extra/clangd/Hover.cpp

 namespace {
 
 PrintingPolicy getPrintingPolicy(PrintingPolicy Base) {
   Base.AnonymousTagLocations = false;
   Base.TerseOutput = true;
   Base.PolishForDeclaration = true;
   Base.ConstantsAsWritten = true;
   Base.SuppressTemplateArgsInCXXConstructors = true;
+  Base.CleanUglifiedParameters = true;
   return Base;
 }
 
 /// Given a declaration \p D, return a human-readable string representing the
 /// local scope in which it is declared, i.e. class(es) and method name. Returns
 /// an empty string if it is not local.
-std::string getLocalScope(const Decl *D) {
+std::string getLocalScope(const Decl *D, const PrintingPolicy &PP) {
   std::vector<std::string> Scopes;
   const DeclContext *DC = D->getDeclContext();
 
   // ObjC scopes won't have multiple components for us to join, instead:
   // - Methods: "-[Class methodParam1:methodParam2]"
   // - Classes, categories, and protocols: "MyClass(Category)"
   if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(DC))
     return printObjCMethod(*MD);
   if (const ObjCContainerDecl *CD = dyn_cast<ObjCContainerDecl>(DC))
     return printObjCContainer(*CD);
 
-  auto GetName = [](const TypeDecl *D) {
+  auto GetName = [&](const TypeDecl *D) {
     if (!D->getDeclName().isEmpty()) {
-      PrintingPolicy Policy = D->getASTContext().getPrintingPolicy();
+      PrintingPolicy Policy = PP;
       Policy.SuppressScope = true;
       return declaredType(D).getAsString(Policy);
     }
     if (auto RD = dyn_cast<RecordDecl>(D))
       return ("(anonymous " + RD->getKindName() + ")").str();
     return std::string("");
   };
   while (DC) {
fetchTemplateParameters(const TemplateParameterList *Params,
   assert(Params);
   std::vector<HoverInfo::Param> TempParameters;
 
   for (const Decl *Param : *Params) {
     HoverInfo::Param P;
     if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
       P.Type = printType(TTP);
 
-      if (!TTP->getName().empty())
-        P.Name = TTP->getNameAsString();
+      if (IdentifierInfo *II = TTP->getIdentifier())
+        P.Name = II->deuglifiedName().str();
 
       if (TTP->hasDefaultArgument())
         P.Default = TTP->getDefaultArgument().getAsString(PP);
     } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
       P.Type = printType(NTTP, PP);
 
       if (IdentifierInfo *II = NTTP->getIdentifier())
-        P.Name = II->getName().str();
+        P.Name = II->deuglifiedName().str();
 
       if (NTTP->hasDefaultArgument()) {
         P.Default.emplace();
         llvm::raw_string_ostream Out(*P.Default);
         NTTP->getDefaultArgument()->printPretty(Out, nullptr, PP);
       }
     } else if (const auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(Param)) {
       P.Type = printType(TTPD, PP);
 
-      if (!TTPD->getName().empty())
-        P.Name = TTPD->getNameAsString();
+      if (IdentifierInfo *II = TTPD->getIdentifier())
+        P.Name = II->deuglifiedName().str();
 
       if (TTPD->hasDefaultArgument()) {
         P.Default.emplace();
         llvm::raw_string_ostream Out(*P.Default);
         TTPD->getDefaultArgument().getArgument().print(PP, Out,
                                                        /*IncludeType*/ false);
       }
     }
const Expr *getDefaultArg(const ParmVarDecl *PVD) {
   return PVD->hasUninstantiatedDefaultArg() ? PVD->getUninstantiatedDefaultArg()
                                             : PVD->getDefaultArg();
 }
 
 HoverInfo::Param toHoverInfoParam(const ParmVarDecl *PVD,
                                   const PrintingPolicy &PP) {
   HoverInfo::Param Out;
   Out.Type = printType(PVD->getType(), PVD->getASTContext(), PP);
-  if (!PVD->getName().empty())
-    Out.Name = PVD->getNameAsString();
+  if (const IdentifierInfo *II = PVD->getIdentifier())
+    Out.Name = II->deuglifiedName().str();
   if (const Expr *DefArg = getDefaultArg(PVD)) {
     Out.Default.emplace();
     llvm::raw_string_ostream OS(*Out.Default);
     DefArg->printPretty(OS, nullptr, PP);
   }
   return Out;
 }
 
HoverInfo getHoverContents(const NamedDecl *D, const PrintingPolicy &PP,
                            const SymbolIndex *Index) {
   HoverInfo HI;
   const ASTContext &Ctx = D->getASTContext();
 
   HI.AccessSpecifier = getAccessSpelling(D->getAccess()).str();
   HI.NamespaceScope = getNamespaceScope(D);
   if (!HI.NamespaceScope->empty())
     HI.NamespaceScope->append("::");
-  HI.LocalScope = getLocalScope(D);
+  HI.LocalScope = getLocalScope(D, PP);
   if (!HI.LocalScope.empty())
     HI.LocalScope.append("::");
 
-  HI.Name = printName(Ctx, *D);
+  HI.Name = printName(Ctx, *D, &PP);
   const auto *CommentD = getDeclForComment(D);
   HI.Documentation = getDeclComment(Ctx, *CommentD);
   enhanceFromIndex(HI, *CommentD, Index);
   if (HI.Documentation.empty())
     HI.Documentation = synthesizeDocumentation(D);
 
   HI.Kind = index::getSymbolInfo(D).Kind;
 

clang-tools-extra/clangd/unittests/HoverTests.cpp

class Foo {})cpp";
        [](HoverInfo &HI) {
          HI.Name = "arr";
          HI.NamespaceScope = "";
          HI.LocalScope = "Test<Size>::";
          HI.AccessSpecifier = "public";
          HI.Kind = index::SymbolKind::Field;
          HI.Definition = "m_int arr[Size]";
          HI.Type = {"m_int[Size]", "int[Size]"};
+       }},
+      {// Uglified standard library parameter names.
+       R"cpp(
+         template<class _Tp> class Tmpl {
+           template<int _I>
+           typename _Tp::iterator ^[[put]](_Tp __value);
+         };
+       )cpp",
+       [](HoverInfo &HI) {
+         HI.Name = "put";
+         HI.NamespaceScope = "";
+         HI.LocalScope = "Tmpl<Tp>::";
+         HI.AccessSpecifier = "private";
+         HI.Kind = index::SymbolKind::InstanceMethod;
+         HI.Definition = "template <int I> typename Tp::iterator put(Tp value)";
+         HI.ReturnType = "typename Tp::iterator";
+         HI.Type = "typename Tp::iterator (Tp)";
+         HI.Parameters = {
+             {{"Tp"}, {"value"}, llvm::None},
+         };
+         HI.TemplateParameters = {
+             {{"int"}, {"I"}, llvm::None},
+         };
+       }},
+      {// Uglified type name.
+       R"cpp(
+          template <typename ^[[_Tp]]> class X;
+        )cpp",
+       [](HoverInfo &HI) {
+         HI.Name = "Tp";
+         HI.Type = "typename";
+         HI.LocalScope = "X<Tp>::";
+         HI.NamespaceScope = "";
+         HI.AccessSpecifier = "public";
+         HI.Definition = "typename Tp";
+         HI.Kind = index::SymbolKind::TemplateTypeParm;
        }}};
   for (const auto &Case : Cases) {
     SCOPED_TRACE(Case.Code);
 
     Annotations T(Case.Code);
     TestTU TU = TestTU::withCode(T.code());
     TU.ExtraArgs.push_back("-std=c++17");
     // Types might be different depending on the target triplet, we chose a

clang-tools-extra/clangd/unittests/SymbolCollectorTests.cpp

TEST_F(SymbolCollectorTest, CanonicalSTLHeader) {
   Language.CPlusPlus = true;
   Includes.addSystemHeadersMapping(Language);
   CollectorOpts.Includes = &Includes;
   runSymbolCollector(
       R"cpp(
       namespace std {
         class string {};
         // Move overloads have special handling.
-        template <typename T> T&& move(T&&);
-        template <typename I, typename O> O move(I, I, O);
+        template <typename _T> T&& move(_T&& __value);
+        template <typename _I, typename _O> _O move(_I, _I, _O);
       }
       )cpp",
       /*Main=*/"");
   EXPECT_THAT(
       Symbols,
       UnorderedElementsAre(
           QName("std"),
           AllOf(QName("std::string"), DeclURI(TestHeaderURI),
                 IncludeHeader("<string>")),
-          AllOf(Labeled("move(T &&)"), IncludeHeader("<utility>")),
+          // Parameter names are demangled.
+          AllOf(Labeled("move(T &&value)"), IncludeHeader("<utility>")),
           AllOf(Labeled("move(I, I, O)"), IncludeHeader("<algorithm>"))));
 }
 
 TEST_F(SymbolCollectorTest, IWYUPragma) {
   CollectorOpts.CollectIncludePath = true;
   CanonicalIncludes Includes;
   PragmaHandler = collectIWYUHeaderMaps(&Includes);
   CollectorOpts.Includes = &Includes;

clang/include/clang/AST/PrettyPrinter.h

PrintingPolicy(const LangOptions &LO)
         Nullptr(LO.CPlusPlus11), Restrict(LO.C99), Alignof(LO.CPlusPlus11),
         UnderscoreAlignof(LO.C11), UseVoidForZeroParams(!LO.CPlusPlus),
         SplitTemplateClosers(!LO.CPlusPlus11), TerseOutput(false),
         PolishForDeclaration(false), Half(LO.Half),
         MSWChar(LO.MicrosoftExt && !LO.WChar), IncludeNewlines(true),
         MSVCFormatting(false), ConstantsAsWritten(false),
         SuppressImplicitBase(false), FullyQualifiedName(false),
         PrintCanonicalTypes(false), PrintInjectedClassNameWithArguments(true),
-        UsePreferredNames(true), AlwaysIncludeTypeForTemplateArgument(false) {}
+        UsePreferredNames(true), AlwaysIncludeTypeForTemplateArgument(false),
+        CleanUglifiedParameters(false) {}
 
   /// Adjust this printing policy for cases where it's known that we're
   /// printing C++ code (for instance, if AST dumping reaches a C++-only
   /// construct). This should not be used if a real LangOptions object is
   /// available.
   void adjustForCPlusPlus() {
     SuppressTagKeyword = true;
     Bool = true;
struct PrintingPolicy {
   /// Whether to use C++ template preferred_name attributes when printing
   /// templates.
   unsigned UsePreferredNames : 1;
 
   /// Whether to use type suffixes (eg: 1U) on integral non-type template
   /// parameters.
   unsigned AlwaysIncludeTypeForTemplateArgument : 1;
 
+  /// Whether to strip underscores when printing reserved parameter names.
+  /// e.g. std::vector<class _Tp> becomes std::vector<class Tp>.
+  /// This only affects parameter names, and so describes a compatible API.
+  unsigned CleanUglifiedParameters : 1;
+
   /// Callbacks to use to allow the behavior of printing to be customized.
   const PrintingCallbacks *Callbacks = nullptr;
 };
 
 } // end namespace clang
 
 #endif

clang/include/clang/Basic/IdentifierTable.h

public:
   bool isEditorPlaceholder() const {
     return getName().startswith("<#") && getName().endswith("#>");
   }
 
   /// Determine whether \p this is a name reserved for the implementation (C99
   /// 7.1.3, C++ [lib.global.names]).
   ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const;
 
+  /// If the identifier is an "uglified" reserved name, return a cleaned form.
+  /// e.g. _Foo => Foo. Otherwise, just returns the name.
+  StringRef deuglifiedName() const;
+
   /// Provide less than operator for lexicographical sorting.
   bool operator<(const IdentifierInfo &RHS) const {
     return getName() < RHS.getName();
   }
 
 private:
   /// The Preprocessor::HandleIdentifier does several special (but rare)
   /// things to identifiers of various sorts.  For example, it changes the

clang/lib/AST/DeclPrinter.cpp

if (D->isModulePrivate())
       Out << "__module_private__ ";
 
     if (D->isConstexpr()) {
       Out << "constexpr ";
       T.removeLocalConst();
     }
   }
 
-  printDeclType(T, D->getName());
+  printDeclType(T, (isa<ParmVarDecl>(D) && Policy.CleanUglifiedParameters &&
+                    D->getIdentifier())
+                       ? D->getIdentifier()->deuglifiedName()
+                       : D->getName());
   Expr *Init = D->getInit();
   if (!Policy.SuppressInitializers && Init) {
     bool ImplicitInit = false;
     if (CXXConstructExpr *Construct =
             dyn_cast<CXXConstructExpr>(Init->IgnoreImplicit())) {
       if (D->getInitStyle() == VarDecl::CallInit &&
           !Construct->isListInitialization()) {
         ImplicitInit = Construct->getNumArgs() == 0 ||
if (const TemplateTemplateParmDecl *TTP =
         dyn_cast<TemplateTemplateParmDecl>(D)) {
     Out << "class";
 
     if (TTP->isParameterPack())
       Out << " ...";
     else if (TTP->getDeclName())
       Out << ' ';
 
-    if (TTP->getDeclName())
+    if (TTP->getDeclName()) {
+      if (Policy.CleanUglifiedParameters && isa<TemplateTemplateParmDecl>(D) &&
+          TTP->getIdentifier())
+        Out << TTP->getIdentifier()->deuglifiedName();
+      else
         Out << TTP->getDeclName();
+    }
   } else if (auto *TD = D->getTemplatedDecl())
     Visit(TD);
   else if (const auto *Concept = dyn_cast<ConceptDecl>(D)) {
     Out << "concept " << Concept->getName() << " = " ;
     Concept->getConstraintExpr()->printPretty(Out, nullptr, Policy, Indentation,
                                               "\n", &Context);
   }
 }
void DeclPrinter::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *TTP) {
   else
     Out << "class";
 
   if (TTP->isParameterPack())
     Out << " ...";
   else if (TTP->getDeclName())
     Out << ' ';
 
-  if (TTP->getDeclName())
+  if (TTP->getDeclName()) {
+    if (Policy.CleanUglifiedParameters && TTP->getIdentifier())
+      Out << TTP->getIdentifier()->deuglifiedName();
+    else
       Out << TTP->getDeclName();
+  }
 
   if (TTP->hasDefaultArgument()) {
     Out << " = ";
     Out << TTP->getDefaultArgument().getAsString(Policy);
   }
 }
 
 void DeclPrinter::VisitNonTypeTemplateParmDecl(
     const NonTypeTemplateParmDecl *NTTP) {
   StringRef Name;
   if (IdentifierInfo *II = NTTP->getIdentifier())
-    Name = II->getName();
+    Name =
+        Policy.CleanUglifiedParameters ? II->deuglifiedName() : II->getName();
   printDeclType(NTTP->getType(), Name, NTTP->isParameterPack());
 
   if (NTTP->hasDefaultArgument()) {
     Out << " = ";
     NTTP->getDefaultArgument()->printPretty(Out, nullptr, Policy, Indentation,
                                             "\n", &Context);
   }
 }

clang/lib/AST/StmtPrinter.cpp

void StmtPrinter::VisitDeclRefExpr(DeclRefExpr *Node) {
   if (const auto *TPOD = dyn_cast<TemplateParamObjectDecl>(Node->getDecl())) {
     TPOD->printAsExpr(OS);
     return;
   }
   if (NestedNameSpecifier *Qualifier = Node->getQualifier())
     Qualifier->print(OS, Policy);
   if (Node->hasTemplateKeyword())
     OS << "template ";
-  OS << Node->getNameInfo();
+  if (Policy.CleanUglifiedParameters &&
+      isa<ParmVarDecl, NonTypeTemplateParmDecl>(Node->getDecl()) &&
+      Node->getDecl()->getIdentifier())
+    OS << Node->getDecl()->getIdentifier()->deuglifiedName();
+  else
+    Node->getNameInfo().printName(OS, Policy);
   if (Node->hasExplicitTemplateArgs()) {
     const TemplateParameterList *TPL = nullptr;
     if (!Node->hadMultipleCandidates())
       if (auto *TD = dyn_cast<TemplateDecl>(Node->getDecl()))
         TPL = TD->getTemplateParameters();
     printTemplateArgumentList(OS, Node->template_arguments(), Policy, TPL);
   }
 }
if (Node->hasExplicitParameters()) {
     CXXMethodDecl *Method = Node->getCallOperator();
     NeedComma = false;
     for (const auto *P : Method->parameters()) {
       if (NeedComma) {
         OS << ", ";
       } else {
         NeedComma = true;
       }
-      std::string ParamStr = P->getNameAsString();
+      std::string ParamStr =
+          (Policy.CleanUglifiedParameters && P->getIdentifier())
+              ? P->getIdentifier()->deuglifiedName().str()
+              : P->getNameAsString();
       P->getOriginalType().print(OS, Policy, ParamStr);
     }
     if (Method->isVariadic()) {
       if (NeedComma)
         OS << ", ";
       OS << "...";
     }
     OS << ')';

clang/lib/AST/TemplateName.cpp

 
 bool TemplateName::containsUnexpandedParameterPack() const {
   return getDependence() & TemplateNameDependence::UnexpandedPack;
 }
 
 void TemplateName::print(raw_ostream &OS, const PrintingPolicy &Policy,
                          Qualified Qual) const {
   if (TemplateDecl *Template = Storage.dyn_cast<TemplateDecl *>())
-    if (Qual == Qualified::Fully &&
-        getDependence() != TemplateNameDependenceScope::DependentInstantiation)
+    if (Policy.CleanUglifiedParameters &&
+        isa<TemplateTemplateParmDecl>(Template) && Template->getIdentifier())
+      OS << Template->getIdentifier()->deuglifiedName();
+    else if (Qual == Qualified::Fully &&
+             getDependence() !=
+                 TemplateNameDependenceScope::DependentInstantiation)
       Template->printQualifiedName(OS, Policy);
     else
       OS << *Template;
   else if (QualifiedTemplateName *QTN = getAsQualifiedTemplateName()) {
     if (Qual == Qualified::Fully &&
         getDependence() !=
             TemplateNameDependenceScope::DependentInstantiation) {
       QTN->getTemplateDecl()->printQualifiedName(OS, Policy);

clang/lib/AST/TypePrinter.cpp

void TypePrinter::printTemplateTypeParmBefore(const TemplateTypeParmType *T,
   TemplateTypeParmDecl *D = T->getDecl();
   if (D && D->isImplicit()) {
     if (auto *TC = D->getTypeConstraint()) {
       TC->print(OS, Policy);
       OS << ' ';
     }
     OS << "auto";
   } else if (IdentifierInfo *Id = T->getIdentifier())
-    OS << Id->getName();
+    OS << (Policy.CleanUglifiedParameters ? Id->deuglifiedName()
+                                          : Id->getName());
   else
     OS << "type-parameter-" << T->getDepth() << '-' << T->getIndex();
 
   spaceBeforePlaceHolder(OS);
 }
 
 void TypePrinter::printTemplateTypeParmAfter(const TemplateTypeParmType *T,
                                              raw_ostream &OS) {}

clang/lib/Basic/IdentifierTable.cpp

IdentifierInfo::isReserved(const LangOptions &LangOpts) const {
 
   // Each name that contains a double underscore (__) is reserved.
   if (LangOpts.CPlusPlus && Name.contains("__"))
     return ReservedIdentifierStatus::ContainsDoubleUnderscore;
 
   return ReservedIdentifierStatus::NotReserved;
 }
 
+StringRef IdentifierInfo::deuglifiedName() const {
+  StringRef Name = getName();
+  if (Name.size() >= 2 && Name.front() == '_' &&
+      (Name[1] == '_' || (Name[1] >= 'A' && Name[1] <= 'Z')))
+    return Name.ltrim('_');
+  return Name;
+}
+
 tok::PPKeywordKind IdentifierInfo::getPPKeywordID() const {
   // We use a perfect hash function here involving the length of the keyword,
   // the first and third character.  For preprocessor ID's there are no
   // collisions (if there were, the switch below would complain about duplicate
   // case values).  Note that this depends on 'if' being null terminated.
 
 #define HASH(LEN, FIRST, THIRD) \
   (LEN << 5) + (((FIRST-'a') + (THIRD-'a')) & 31)

clang/lib/Sema/SemaCodeComplete.cpp

 
 static PrintingPolicy getCompletionPrintingPolicy(const ASTContext &Context,
                                                   const Preprocessor &PP) {
   PrintingPolicy Policy = Sema::getPrintingPolicy(Context, PP);
   Policy.AnonymousTagLocations = false;
   Policy.SuppressStrongLifetime = true;
   Policy.SuppressUnwrittenScope = true;
   Policy.SuppressScope = true;
+  Policy.CleanUglifiedParameters = true;
   return Policy;
 }
 
 /// Retrieve a printing policy suitable for code completion.
 static PrintingPolicy getCompletionPrintingPolicy(Sema &S) {
   return getCompletionPrintingPolicy(S.Context, S.PP);
 }
 
FormatFunctionParameter(const PrintingPolicy &Policy, const ParmVarDecl *Param,
   bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->getDeclContext());
   if (Param->getType()->isDependentType() ||
       !Param->getType()->isBlockPointerType()) {
     // The argument for a dependent or non-block parameter is a placeholder
     // containing that parameter's type.
     std::string Result;
 
     if (Param->getIdentifier() && !ObjCMethodParam && !SuppressName)
-      Result = std::string(Param->getIdentifier()->getName());
+      Result = std::string(Param->getIdentifier()->deuglifiedName());
 
     QualType Type = Param->getType();
     if (ObjCSubsts)
       Type = Type.substObjCTypeArgs(Param->getASTContext(), *ObjCSubsts,
                                     ObjCSubstitutionContext::Parameter);
     if (ObjCMethodParam) {
       Result =
           "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier(), Type);
       Result += Type.getAsString(Policy) + ")";
       if (Param->getIdentifier() && !SuppressName)
-        Result += Param->getIdentifier()->getName();
+        Result += Param->getIdentifier()->deuglifiedName();
     } else {
       Type.getAsStringInternal(Result, Policy);
     }
     return Result;
   }
 
   // The argument for a block pointer parameter is a block literal with
   // the appropriate type.
if (const auto *PD = cast<ObjCMethodDecl>(Param->getDeclContext())
                                    SuppressBlock);
   }
 
   if (!Block) {
     // We were unable to find a FunctionProtoTypeLoc with parameter names
     // for the block; just use the parameter type as a placeholder.
     std::string Result;
     if (!ObjCMethodParam && Param->getIdentifier())
-      Result = std::string(Param->getIdentifier()->getName());
+      Result = std::string(Param->getIdentifier()->deuglifiedName());
 
     QualType Type = Param->getType().getUnqualifiedType();
 
     if (ObjCMethodParam) {
       Result = Type.getAsString(Policy);
       std::string Quals =
           formatObjCParamQualifiers(Param->getObjCDeclQualifier(), Type);
       if (!Quals.empty())
         Result = "(" + Quals + " " + Result + ")";
       if (Result.back() != ')')
         Result += " ";
       if (Param->getIdentifier())
-        Result += Param->getIdentifier()->getName();
+        Result += Param->getIdentifier()->deuglifiedName();
     } else {
       Type.getAsStringInternal(Result, Policy);
     }
 
     return Result;
   }
 
   // We have the function prototype behind the block pointer type, as it was
if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
         llvm::raw_string_ostream OS(PlaceholderStr);
         TC->print(OS, Policy);
         OS.flush();
       } else
         PlaceholderStr = "class";
 
       if (TTP->getIdentifier()) {
         PlaceholderStr += ' ';
-        PlaceholderStr += TTP->getIdentifier()->getName();
+        PlaceholderStr += TTP->getIdentifier()->deuglifiedName();
       }
 
       HasDefaultArg = TTP->hasDefaultArgument();
     } else if (NonTypeTemplateParmDecl *NTTP =
                    dyn_cast<NonTypeTemplateParmDecl>(*P)) {
       if (NTTP->getIdentifier())
-        PlaceholderStr = std::string(NTTP->getIdentifier()->getName());
+        PlaceholderStr = std::string(NTTP->getIdentifier()->deuglifiedName());
       NTTP->getType().getAsStringInternal(PlaceholderStr, Policy);
       HasDefaultArg = NTTP->hasDefaultArgument();
     } else {
       assert(isa<TemplateTemplateParmDecl>(*P));
       TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
 
       // Since putting the template argument list into the placeholder would
       // be very, very long, we just use an abbreviation.
       PlaceholderStr = "template<...> class";
       if (TTP->getIdentifier()) {
         PlaceholderStr += ' ';
-        PlaceholderStr += TTP->getIdentifier()->getName();
+        PlaceholderStr += TTP->getIdentifier()->deuglifiedName();
       }
 
       HasDefaultArg = TTP->hasDefaultArgument();
     }
 
     if (HasDefaultArg && !InDefaultArg) {
       // When we see an optional default argument, put that argument and
       // the remaining default arguments into a new, optional string.

clang/test/CodeCompletion/deuglify.cpp

+// Fake standard library with uglified names.
+// Parameters (including template params) get ugliness stripped.
+namespace std {
+
+template <typename _Tp>
+class __vector_base {};
+
+template <typename _Tp>
+class vector : private __vector_base<_Tp> {
+public:
+  _Tp &at(unsigned __index) const;
+  int __stays_ugly();
+};
+
+} // namespace std
+
+int x = std::vector<int>{}.at(42);
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:17:14 %s -o - | FileCheck -check-prefix=CHECK-CC1 %s
+// CHECK-CC1: COMPLETION: __vector_base : __vector_base<<#typename Tp#>>
+// CHECK-CC1: COMPLETION: vector : vector<<#typename Tp#>>
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:17:28 %s -o - | FileCheck -check-prefix=CHECK-CC2 %s
+// CHECK-CC2: COMPLETION: __stays_ugly : [#int#]__stays_ugly()
+// CHECK-CC2: COMPLETION: at : [#int &#]at(<#unsigned int index#>)[# const#]
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:17:31 %s -o - | FileCheck -check-prefix=CHECK-CC3 %s
+// CHECK-CC3: OVERLOAD: [#int &#]at(<#unsigned int index#>)

clang/unittests/AST/DeclPrinterTest.cpp

TEST(DeclPrinter, TestTemplateArgumentList16) {
   llvm::StringLiteral Code = "template<typename T1, int NT1, typename T2 = "
                              "bool, int NT2 = 5> struct Z {};";
   ASSERT_TRUE(PrintedDeclCXX11Matches(Code, "T1", "typename T1"));
   ASSERT_TRUE(PrintedDeclCXX11Matches(Code, "T2", "typename T2 = bool"));
   ASSERT_TRUE(PrintedDeclCXX11Matches(Code, "NT1", "int NT1"));
   ASSERT_TRUE(PrintedDeclCXX11Matches(Code, "NT2", "int NT2 = 5"));
 }
 
+TEST(DeclPrinter, TestFunctionParamUglified) {
+  llvm::StringLiteral Code = R"cpp(
+    class __c;
+    void _A(__c *__param);
+  )cpp";
+  auto Clean = [](PrintingPolicy &Policy) {
+    Policy.CleanUglifiedParameters = true;
+  };
+
+  ASSERT_TRUE(PrintedDeclCXX17Matches(Code, namedDecl(hasName("_A")).bind("id"),
+                                      "void _A(__c *__param)"));
+  ASSERT_TRUE(PrintedDeclCXX17Matches(Code, namedDecl(hasName("_A")).bind("id"),
+                                      "void _A(__c *param)", Clean));
+}
+
+TEST(DeclPrinter, TestTemplateParamUglified) {
+  llvm::StringLiteral Code = R"cpp(
+    template <typename _Tp, int __n, template <typename> class _Container>
+    struct _A{};
+  )cpp";
+  auto Clean = [](PrintingPolicy &Policy) {
+    Policy.CleanUglifiedParameters = true;
+  };
+
+  ASSERT_TRUE(PrintedDeclCXX17Matches(
+      Code, classTemplateDecl(hasName("_A")).bind("id"),
+      "template <typename _Tp, int __n, template <typename> class _Container> "
+      "struct _A {}"));
+  ASSERT_TRUE(PrintedDeclCXX17Matches(
+      Code, classTemplateDecl(hasName("_A")).bind("id"),
+      "template <typename Tp, int n, template <typename> class Container> "
+      "struct _A {}",
+      Clean));
+}
+
 TEST(DeclPrinter, TestStaticAssert1) {
   ASSERT_TRUE(PrintedDeclCXX17Matches("static_assert(true);",
                                       staticAssertDecl().bind("id"),
                                       "static_assert(true)"));
 }
 
 TEST(DeclPrinter, TestObjCMethod1) {
   ASSERT_TRUE(PrintedDeclObjCMatches(

clang/unittests/AST/StmtPrinterTest.cpp

ASSERT_TRUE(PrintedStmtCXXMatches(StdVer::CXX11, CPPSource,
                                     "[] {\n    return 0;\n}"));
 
   // body not printed when TerseOutput is on.
   ASSERT_TRUE(PrintedStmtCXXMatches(
       StdVer::CXX11, CPPSource, lambdaExpr(anything()).bind("id"), "[] {}",
 
       [](PrintingPolicy &PP) { PP.TerseOutput = true; }));
 }
+
+TEST(StmtPrinter, ParamsUglified) {
+  llvm::StringLiteral Code = R"cpp(
+    template <typename _T, int _I, template <typename> class _C>
+    auto foo(int __j) {
+      return typename _C<_T>::_F(_I, __j);
+    }
+  )cpp";
+  auto Clean = [](PrintingPolicy &Policy) {
+    Policy.CleanUglifiedParameters = true;
+  };
+
+  ASSERT_TRUE(PrintedStmtCXXMatches(StdVer::CXX14, Code,
+                                    returnStmt().bind("id"),
+                                    "return typename _C<_T>::_F(_I, __j);\n"));
+  ASSERT_TRUE(
+      PrintedStmtCXXMatches(StdVer::CXX14, Code, returnStmt().bind("id"),
+                            "return typename C<T>::_F(I, j);\n", Clean));
+}

clang/unittests/AST/TypePrinterTest.cpp

TEST(TypePrinter, TemplateId) {
 
   ASSERT_TRUE(PrintedTypeMatches(
       Code, {}, Matcher, "const Type<T> &",
       [](PrintingPolicy &Policy) { Policy.FullyQualifiedName = false; }));
 
   ASSERT_TRUE(PrintedTypeMatches(
       Code, {}, Matcher, "const N::Type<T> &",
       [](PrintingPolicy &Policy) { Policy.FullyQualifiedName = true; }));
-}
+}
+
+TEST(TypePrinter, ParamsUglified) {
+  llvm::StringLiteral Code = R"cpp(
+    template <typename _Tp, template <typename> class __f>
+    const __f<_Tp&> *A = nullptr;
+  )cpp";
+  auto Clean = [](PrintingPolicy &Policy) {
+    Policy.CleanUglifiedParameters = true;
+  };
+
+  ASSERT_TRUE(PrintedTypeMatches(Code, {},
+                                 varDecl(hasType(qualType().bind("id"))),
+                                 "const __f<_Tp &> *", nullptr));
+  ASSERT_TRUE(PrintedTypeMatches(Code, {},
+                                 varDecl(hasType(qualType().bind("id"))),
+                                 "const f<Tp &> *", Clean));
+}