code review

Author: MythreyaK

clang/lib/Sema/SemaCodeComplete.cpp

@@ -413,6 +413,37 @@ class ResultBuilder {
   bool IsImpossibleToSatisfy(const NamedDecl *ND) const;
   //@}
 };
+
+void AddFunctionTypeQuals(CodeCompletionBuilder &Result,
+                          const Qualifiers Quals) {
+  // FIXME: Add ref-qualifier!
+
+  // Handle single qualifiers without copying
+  if (Quals.hasOnlyConst()) {
+    Result.AddInformativeChunk(" const");
+    return;
+  }
+
+  if (Quals.hasOnlyVolatile()) {
+    Result.AddInformativeChunk(" volatile");
+    return;
+  }
+
+  if (Quals.hasOnlyRestrict()) {
+    Result.AddInformativeChunk(" restrict");
+    return;
+  }
+
+  // Handle multiple qualifiers.
+  std::string QualsStr;
+  if (Quals.hasConst())
+    QualsStr += " const";
+  if (Quals.hasVolatile())
+    QualsStr += " volatile";
+  if (Quals.hasRestrict())
+    QualsStr += " restrict";
+  Result.AddInformativeChunk(Result.getAllocator().CopyString(QualsStr));
+}
 } // namespace
 
 void PreferredTypeBuilder::enterReturn(Sema &S, SourceLocation Tok) {
@@ -1436,7 +1467,7 @@ void ResultBuilder::AddResult(Result R, DeclContext *CurContext,
   AdjustResultPriorityForDecl(R);
 
   // Account for explicit object parameter
-  const auto getQualifiers = [&](const CXXMethodDecl *MethodDecl) {
+  const auto GetQualifiers = [&](const CXXMethodDecl *MethodDecl) {
     if (MethodDecl->isExplicitObjectMemberFunction())
       return MethodDecl->getFunctionObjectParameterType().getQualifiers();
     else
@@ -1455,7 +1486,7 @@ void ResultBuilder::AddResult(Result R, DeclContext *CurContext,
   if (HasObjectTypeQualifiers)
     if (const auto *Method = dyn_cast<CXXMethodDecl>(R.Declaration))
       if (Method->isInstance()) {
-        Qualifiers MethodQuals = getQualifiers(Method);
+        Qualifiers MethodQuals = GetQualifiers(Method);
         if (ObjectTypeQualifiers == MethodQuals)
           R.Priority += CCD_ObjectQualifierMatch;
         else if (ObjectTypeQualifiers - MethodQuals) {
@@ -3438,19 +3469,15 @@ static void AddQualifierToCompletionString(CodeCompletionBuilder &Result,
 // object
 static void AddCXXExplicitObjectFunctionTypeQualsToCompletionString(
     CodeCompletionBuilder &Result, const CXXMethodDecl *Function) {
-  const auto Quals = Function->getFunctionObjectParameterType();
+  assert(isa<CXXMethodDecl>(Function) &&
+         Function->hasCXXExplicitFunctionObjectParameter() &&
+         "Valid only on CXX explicit object methods");
 
+  const auto Quals = Function->getFunctionObjectParameterType();
   if (!Quals.hasQualifiers())
     return;
 
-  std::string QualsStr;
-  if (Quals.getQualifiers().hasConst())
-    QualsStr += " const";
-  if (Quals.getQualifiers().hasVolatile())
-    QualsStr += " volatile";
-  if (Quals.getQualifiers().hasRestrict())
-    QualsStr += " restrict";
-  Result.AddInformativeChunk(Result.getAllocator().CopyString(QualsStr));
+  AddFunctionTypeQuals(Result, Quals.getQualifiers());
 }
 
 static void
@@ -3461,40 +3488,13 @@ AddFunctionTypeQualsToCompletionString(CodeCompletionBuilder &Result,
     // if explicit object method, infer quals from the object parameter
     AddCXXExplicitObjectFunctionTypeQualsToCompletionString(Result,
                                                             CxxMethodDecl);
-    return;
-  }
-
-  const auto *Proto = Function->getType()->getAs<FunctionProtoType>();
-  if (!Proto || !Proto->getMethodQuals())
-    return;
-
-  // FIXME: Add ref-qualifier!
-
-  // Handle single qualifiers without copying
-  if (Proto->getMethodQuals().hasOnlyConst()) {
-    Result.AddInformativeChunk(" const");
-    return;
-  }
-
-  if (Proto->getMethodQuals().hasOnlyVolatile()) {
-    Result.AddInformativeChunk(" volatile");
-    return;
-  }
+  } else {
+    const auto *Proto = Function->getType()->getAs<FunctionProtoType>();
+    if (!Proto || !Proto->getMethodQuals())
+      return;
 
-  if (Proto->getMethodQuals().hasOnlyRestrict()) {
-    Result.AddInformativeChunk(" restrict");
-    return;
+    AddFunctionTypeQuals(Result, Proto->getMethodQuals());
   }
-
-  // Handle multiple qualifiers.
-  std::string QualsStr;
-  if (Proto->isConst())
-    QualsStr += " const";
-  if (Proto->isVolatile())
-    QualsStr += " volatile";
-  if (Proto->isRestrict())
-    QualsStr += " restrict";
-  Result.AddInformativeChunk(Result.getAllocator().CopyString(QualsStr));
 }
 
 static void