Provide a fix-it hint for -Wswitch, which adds missing cases. If there are >3 cases, the inserted text will contain newlines so it will not be shown in console output (but will be applied by -fixit, available to libclang and clangd, etc).

[sammccall]

Summary

Lifted the helper for spelling one scope from another from
SemaCodeComplete -> AST, to reuse it. It should be useful in other contexts too.

[sammccall]

Ping... it'd be nice to have for clangd-9, though it's getting late.

[ilya-biryukov]

One major drawback that I see is the lack of indentation (and other format options) in the added code.
Should we have this fix at a higher level that can have formatting (either now or in the future)? E.g. in clangd directly?

lib/Sema/SemaStmt.cpp

1208

Maybe always put each case on a new line?
From my experience, having multiple cases on the same line is not very common.

[iamsergio]

I don't think we need to worry about formatting, that's the IDE's job (and whatever formatter it uses).
In general, the code that knows how to warn should also be the one that knows how to fix it, this looks like a good place to me.

Can we unblock this ? Probably this anymore though.

[aaron.ballman]

In D63085#3384302, @iamsergio wrote:

I don't think we need to worry about formatting, that's the IDE's job (and whatever formatter it uses).
In general, the code that knows how to warn should also be the one that knows how to fix it, this looks like a good place to me.

Can we unblock this ? Probably this anymore though.

I don't think formatting concerns should block progress on this; we expect users to run clang-format to fix formatting issues instead of hoping the fix-it system gets it right.

[Trass3r]

That's the general approach for clang-tidy use too, rely on clang-format for formatting the fixes.

include/clang/AST/DeclBase.h

 class ExternalSourceSymbolAttr;
 class FunctionDecl;
 class FunctionType;
 class IdentifierInfo;
 enum Linkage : unsigned char;
 class LinkageSpecDecl;
 class Module;
 class NamedDecl;
+class NestedNameSpecifier;
 class ObjCCategoryDecl;
 class ObjCCategoryImplDecl;
 class ObjCContainerDecl;
 class ObjCImplDecl;
 class ObjCImplementationDecl;
 class ObjCInterfaceDecl;
 class ObjCMethodDecl;
 class ObjCProtocolDecl;
public:
   }
 
   /// Retrieve the outermost lexically enclosing record context.
   RecordDecl *getOuterLexicalRecordContext();
   const RecordDecl *getOuterLexicalRecordContext() const {
     return const_cast<DeclContext *>(this)->getOuterLexicalRecordContext();
   }
 
+  /// Compute the qualification required to get from the current context to
+  /// the target context. Useful for suggesting spellings (e.g. in FixItHints).
+  ///
+  /// \returns a nested name specifier that refers into the target context, or
+  /// nullptr if no qualification is needed or possible.
+  NestedNameSpecifier *getQualifierFor(const DeclContext *Target) const;
+
   /// Test if this context is part of the enclosing namespace set of
   /// the context NS, as defined in C++0x [namespace.def]p9. If either context
   /// isn't a namespace, this is equivalent to Equals().
   ///
   /// The enclosing namespace set of a namespace is the namespace and, if it is
   /// inline, its enclosing namespace, recursively.
   bool InEnclosingNamespaceSetOf(const DeclContext *NS) const;
 

lib/AST/DeclBase.cpp

RecordDecl *DeclContext::getOuterLexicalRecordContext() {
   DeclContext *DC = this;
   while (DC->isRecord()) {
     OutermostRD = cast<RecordDecl>(DC);
     DC = DC->getLexicalParent();
   }
   return OutermostRD;
 }
 
+NestedNameSpecifier *
+DeclContext::getQualifierFor(const DeclContext *Target) const {
+  SmallVector<const DeclContext *, 4> TargetParents;
+
+  for (const DeclContext *CommonAncestor = Target;
+       CommonAncestor && !CommonAncestor->Encloses(this);
+       CommonAncestor = CommonAncestor->getLookupParent()) {
+    if (CommonAncestor->isTransparentContext() ||
+        CommonAncestor->isFunctionOrMethod())
+      continue;
+
+    TargetParents.push_back(CommonAncestor);
+  }
+
+  NestedNameSpecifier *Result = nullptr;
+  while (!TargetParents.empty()) {
+    const DeclContext *Parent = TargetParents.pop_back_val();
+
+    if (const auto *Namespace = dyn_cast<NamespaceDecl>(Parent)) {
+      if (Namespace->isAnonymousNamespace() || Namespace->isInline())
+        continue;
+
+      Result =
+          NestedNameSpecifier::Create(getParentASTContext(), Result, Namespace);
+    } else if (const auto *TD = dyn_cast<TagDecl>(Parent))
+      Result = NestedNameSpecifier::Create(
+          getParentASTContext(), Result, false,
+          getParentASTContext().getTypeDeclType(TD).getTypePtr());
+  }
+  return Result;
+}
+
 bool DeclContext::InEnclosingNamespaceSetOf(const DeclContext *O) const {
   // For non-file contexts, this is equivalent to Equals.
   if (!isFileContext())
     return O->Equals(this);
 
   do {
     if (O->Equals(this))
       return true;

lib/Sema/SemaCodeComplete.cpp

 ResultBuilder::ShadowMapEntry::iterator
 ResultBuilder::ShadowMapEntry::end() const {
   if (DeclOrVector.is<const NamedDecl *>() || DeclOrVector.isNull())
     return iterator();
 
   return iterator(DeclOrVector.get<DeclIndexPairVector *>()->end());
 }
 
-/// Compute the qualification required to get from the current context
-/// (\p CurContext) to the target context (\p TargetContext).
-///
-/// \param Context the AST context in which the qualification will be used.
-///
-/// \param CurContext the context where an entity is being named, which is
-/// typically based on the current scope.
-///
-/// \param TargetContext the context in which the named entity actually
-/// resides.
-///
-/// \returns a nested name specifier that refers into the target context, or
-/// NULL if no qualification is needed.
-static NestedNameSpecifier *
-getRequiredQualification(ASTContext &Context, const DeclContext *CurContext,
-                         const DeclContext *TargetContext) {
-  SmallVector<const DeclContext *, 4> TargetParents;
-
-  for (const DeclContext *CommonAncestor = TargetContext;
-       CommonAncestor && !CommonAncestor->Encloses(CurContext);
-       CommonAncestor = CommonAncestor->getLookupParent()) {
-    if (CommonAncestor->isTransparentContext() ||
-        CommonAncestor->isFunctionOrMethod())
-      continue;
-
-    TargetParents.push_back(CommonAncestor);
-  }
-
-  NestedNameSpecifier *Result = nullptr;
-  while (!TargetParents.empty()) {
-    const DeclContext *Parent = TargetParents.pop_back_val();
-
-    if (const auto *Namespace = dyn_cast<NamespaceDecl>(Parent)) {
-      if (!Namespace->getIdentifier())
-        continue;
-
-      Result = NestedNameSpecifier::Create(Context, Result, Namespace);
-    } else if (const auto *TD = dyn_cast<TagDecl>(Parent))
-      Result = NestedNameSpecifier::Create(
-          Context, Result, false, Context.getTypeDeclType(TD).getTypePtr());
-  }
-  return Result;
-}
-
 /// Determine whether \p Id is a name reserved for the implementation (C99
 /// 7.1.3, C++ [lib.global.names]).
 static bool isReservedName(const IdentifierInfo *Id,
                            bool doubleUnderscoreOnly = false) {
   if (Id->getLength() < 2)
     return false;
   const char *Name = Id->getNameStart();
   return Name[0] == '_' &&
bool ResultBuilder::CheckHiddenResult(Result &R, DeclContext *CurContext,
   if (HiddenCtx == Hiding->getDeclContext()->getRedeclContext())
     return true;
 
   // We can refer to the result with the appropriate qualification. Do it.
   R.Hidden = true;
   R.QualifierIsInformative = false;
 
   if (!R.Qualifier)
-    R.Qualifier = getRequiredQualification(SemaRef.Context, CurContext,
-                                           R.Declaration->getDeclContext());
+    R.Qualifier = CurContext->getQualifierFor(R.Declaration->getDeclContext());
   return false;
 }
 
 /// A simplified classification of types used to determine whether two
 /// types are "similar enough" when adjusting priorities.
 SimplifiedTypeClass clang::getSimplifiedTypeClass(CanQualType T) {
   switch (T->getTypeClass()) {
   case Type::Builtin:
static void MaybeAddOverrideCalls(Sema &S, DeclContext *InContext,
   for (const CXXMethodDecl *Overridden : Method->overridden_methods()) {
     CodeCompletionBuilder Builder(Results.getAllocator(),
                                   Results.getCodeCompletionTUInfo());
     if (Overridden->getCanonicalDecl() == Method->getCanonicalDecl())
       continue;
 
     // If we need a nested-name-specifier, add one now.
     if (!InContext) {
-      NestedNameSpecifier *NNS = getRequiredQualification(
-          S.Context, CurContext, Overridden->getDeclContext());
+      NestedNameSpecifier *NNS =
+          CurContext->getQualifierFor(Overridden->getDeclContext());
       if (NNS) {
         std::string Str;
         llvm::raw_string_ostream OS(Str);
         NNS->print(OS, Policy);
         Builder.AddTextChunk(Results.getAllocator().CopyString(OS.str()));
       }
     } else if (!InContext->Equals(Overridden->getDeclContext()))
       continue;

 static void AddEnumerators(ResultBuilder &Results, ASTContext &Context,
                            EnumDecl *Enum, DeclContext *CurContext,
                            const CoveredEnumerators &Enumerators) {
   NestedNameSpecifier *Qualifier = Enumerators.SuggestedQualifier;
   if (Context.getLangOpts().CPlusPlus && !Qualifier && Enumerators.Seen.empty()) {
     // If there are no prior enumerators in C++, check whether we have to
     // qualify the names of the enumerators that we suggest, because they
     // may not be visible in this scope.
-    Qualifier = getRequiredQualification(Context, CurContext, Enum);
+    Qualifier = CurContext->getQualifierFor(Enum);
   }
 
   Results.EnterNewScope();
   for (auto *E : Enum->enumerators()) {
     if (Enumerators.Seen.count(E))
       continue;
 
     CodeCompletionResult R(E, CCP_EnumInCase, Qualifier);

lib/Sema/SemaLookup.cpp

 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclLookups.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
+#include "clang/AST/NestedNameSpecifier.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/ModuleLoader.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Overload.h"

lib/Sema/SemaStmt.cpp

if (!CaseListIsErroneous && !CaseListIsIncomplete && !HasConstantCond &&
         }
       }
 
       if (TheDefaultStmt && UnhandledNames.empty() && ED->isClosedNonFlag())
         Diag(TheDefaultStmt->getDefaultLoc(), diag::warn_unreachable_default);
 
       // Produce a nice diagnostic if multiple values aren't handled.
       if (!UnhandledNames.empty()) {
-        DiagnosticBuilder DB = Diag(CondExpr->getExprLoc(),
-                                    TheDefaultStmt ? diag::warn_def_missing_case
-                                                   : diag::warn_missing_case)
-                               << (int)UnhandledNames.size();
+        DiagnosticBuilder DB =
+            Diag(CondExpr->getExprLoc(), TheDefaultStmt
+                                             ? diag::warn_def_missing_case
 
         for (size_t I = 0, E = std::min(UnhandledNames.size(), (size_t)3);
              I != E; ++I)
           DB << UnhandledNames[I];
+
+        std::string NewCases;
+        llvm::raw_string_ostream NewCasesOS(NewCases);
+        // Include \n to separate new cases added if there are many.
+        // This suppresses printing the (long) insert text.
+        char Sep = UnhandledNames.size() > 3 ? '\n' : ' ';
+        const NestedNameSpecifier *Qual =
+            CurContext->getQualifierFor(ED->isScoped() ? ED : ED->getParent());
+        for (const auto& Name : UnhandledNames) {
+          NewCasesOS << "case ";
+          if (Qual)
+            Qual->print(NewCasesOS, Context.getPrintingPolicy());
+          NewCasesOS << Name << ':' << Sep;
+        }
+        NewCasesOS << "break;";
+        DB << FixItHint::CreateInsertion(SS->getEndLoc(), NewCasesOS.str());
       }
 
       if (!hasCasesNotInSwitch)
         SS->setAllEnumCasesCovered();
     }
   }
 
   if (BodyStmt)

test/FixIt/fixit-enum.cpp

+// RUN: cp %s %t.cpp
+// RUN: not %clang_cc1 -fixit %t.cpp -Werror
+// RUN: %clang_cc1 %t.cpp -Werror
+
+namespace ns {
+inline namespace q { namespace { enum { A, B, C }; } }
+} // namespace ns
+
+namespace ns2 {
+enum class F { X, Y, Z };
+
+void test(F f, decltype(ns::A) g) {
+  switch (f) {}
+  // CHECK: YYY
+
+  switch (g) {}
+  // CHECK: ZZZ
+}
+} // namespace ns2