[Sema] Allow disabling typo correction when doing code completion.

[ilya-biryukov]

lib/Sema/Sema.cpp

143

It seems weird that typo-correction is only controlled by CodeCompleter for all of Sema.
I wonder whether putting that into FrontendOptions makes more sense. WDYT?

[hokein]

lib/Sema/Sema.cpp

143

Yeah, it is weird.

After looking through the code of Sema, modifying DisableTypoCorrection is not the right way - as this method variable is controlled by Sema internally (it will change the value back and forth).

Fortunately I figured out clang already provides a way to control the typo correction. We don't need this patch. Sorry for the noise.

include/clang/Sema/CodeCompleteConsumer.h

public:
   }
 
   /// \brief Hint whether to load data from the external AST in order to provide
   /// full results. If false, declarations from the preamble may be omitted.
   bool loadExternal() const {
     return CodeCompleteOpts.LoadExternal;
   }
 
+  /// \breif Whether to disable typo correction when Sema does code completion.
+  bool disableTypoCorrection() const {
+    return CodeCompleteOpts.DisableTypoCorrection;
+  }
+
   /// \brief Determine whether the output of this consumer is binary.
   bool isOutputBinary() const { return OutputIsBinary; }
 
   /// \brief Deregisters and destroys this code-completion consumer.
   virtual ~CodeCompleteConsumer();
 
   /// \name Code-completion filtering
   /// \brief Check if the result should be filtered out.

include/clang/Sema/CodeCompleteOptions.h

public:
 
   /// Show brief documentation comments in code completion results.
   unsigned IncludeBriefComments : 1;
 
   /// Hint whether to load data from the external AST in order to provide
   /// full results. If false, declarations from the preamble may be omitted.
   unsigned LoadExternal : 1;
 
+  /// Whether to disable typo correction when Sema does code completion.
+  unsigned DisableTypoCorrection : 1;
+
   CodeCompleteOptions()
       : IncludeMacros(0), IncludeCodePatterns(0), IncludeGlobals(1),
         IncludeNamespaceLevelDecls(1), IncludeBriefComments(0),
-        LoadExternal(1) {}
+        LoadExternal(1), DisableTypoCorrection(0) {}
 };
 
 } // namespace clang
 
 #endif
 

lib/Sema/Sema.cpp

 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/Preprocessor.h"
+#include "clang/Sema/CodeCompleteConsumer.h"
 #include "clang/Sema/CXXFieldCollector.h"
 #include "clang/Sema/DelayedDiagnostic.h"
 #include "clang/Sema/ExternalSemaSource.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/MultiplexExternalSemaSource.h"
 #include "clang/Sema/ObjCMethodList.h"
 #include "clang/Sema/PrettyDeclStackTrace.h"
 #include "clang/Sema/Scope.h"
: ExternalSource(nullptr), isMultiplexExternalSource(false),
       NSValueDecl(nullptr), NSStringDecl(nullptr),
       StringWithUTF8StringMethod(nullptr),
       ValueWithBytesObjCTypeMethod(nullptr), NSArrayDecl(nullptr),
       ArrayWithObjectsMethod(nullptr), NSDictionaryDecl(nullptr),
       DictionaryWithObjectsMethod(nullptr), GlobalNewDeleteDeclared(false),
       TUKind(TUKind), NumSFINAEErrors(0), AccessCheckingSFINAE(false),
       InNonInstantiationSFINAEContext(false), NonInstantiationEntries(0),
       ArgumentPackSubstitutionIndex(-1), CurrentInstantiationScope(nullptr),
-      DisableTypoCorrection(false), TyposCorrected(0), AnalysisWarnings(*this),
+      DisableTypoCorrection(
+          CodeCompleter ? CodeCompleter->disableTypoCorrection() : false),
+      TyposCorrected(0), AnalysisWarnings(*this),
       ThreadSafetyDeclCache(nullptr), VarDataSharingAttributesStack(nullptr),
       CurScope(nullptr), Ident_super(nullptr), Ident___float128(nullptr) {
   TUScope = nullptr;
 
   LoadedExternalKnownNamespaces = false;
   for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)
     NSNumberLiteralMethods[I] = nullptr;
 

unittests/Sema/CodeCompleteTest.cpp

 using namespace clang::tooling;
 using ::testing::UnorderedElementsAre;
 
 const char TestCCName[] = "test.cc";
 using VisitedContextResults = std::vector<std::string>;
 
 class VisitedContextFinder: public CodeCompleteConsumer {
 public:
-  VisitedContextFinder(VisitedContextResults &Results)
-      : CodeCompleteConsumer(/*CodeCompleteOpts=*/{},
+  VisitedContextFinder(VisitedContextResults &Results,
+                       const CodeCompleteOptions &CCOpts)
+      : CodeCompleteConsumer(CCOpts,
                              /*CodeCompleteConsumer*/ false),
         VCResults(Results),
         CCTUInfo(std::make_shared<GlobalCodeCompletionAllocator>()) {}
 
   void ProcessCodeCompleteResults(Sema &S, CodeCompletionContext Context,
                                   CodeCompletionResult *Results,
                                   unsigned NumResults) override {
     VisitedContexts = Context.getVisitedContexts();

 private:
   VisitedContextResults& VCResults;
   CodeCompletionTUInfo CCTUInfo;
   CodeCompletionContext::VisitedContextSet VisitedContexts;
 };
 
 class CodeCompleteAction : public SyntaxOnlyAction {
 public:
-  CodeCompleteAction(ParsedSourceLocation P, VisitedContextResults &Results)
-      : CompletePosition(std::move(P)), VCResults(Results) {}
+  CodeCompleteAction(ParsedSourceLocation P, const CodeCompleteOptions &CCOpts,
+                     VisitedContextResults &Results)
+      : CompletePosition(std::move(P)), CCOpts(std::move(CCOpts)),
+        VCResults(Results) {}
 
   bool BeginInvocation(CompilerInstance &CI) override {
     CI.getFrontendOpts().CodeCompletionAt = CompletePosition;
-    CI.setCodeCompletionConsumer(new VisitedContextFinder(VCResults));
+    CI.setCodeCompletionConsumer(new VisitedContextFinder(VCResults, CCOpts));
     return true;
   }
 
 private:
   // 1-based code complete position <Line, Col>;
   ParsedSourceLocation CompletePosition;
+  CodeCompleteOptions CCOpts;
   VisitedContextResults& VCResults;
 };
 
 ParsedSourceLocation offsetToPosition(llvm::StringRef Code, size_t Offset) {
   Offset = std::min(Code.size(), Offset);
   StringRef Before = Code.substr(0, Offset);
   int Lines = Before.count('\n');
   size_t PrevNL = Before.rfind('\n');
   size_t StartOfLine = (PrevNL == StringRef::npos) ? 0 : (PrevNL + 1);
   return {TestCCName, static_cast<unsigned>(Lines + 1),
           static_cast<unsigned>(Offset - StartOfLine + 1)};
 }
 
-VisitedContextResults runCodeCompleteOnCode(StringRef Code) {
+VisitedContextResults
+runCodeCompleteOnCode(StringRef Code, const CodeCompleteOptions &CCOpts = {}) {
   VisitedContextResults Results;
   auto TokenOffset = Code.find('^');
   assert(TokenOffset != StringRef::npos &&
          "Completion token ^ wasn't found in Code.");
   std::string WithoutToken = Code.take_front(TokenOffset);
   WithoutToken += Code.drop_front(WithoutToken.size() + 1);
   assert(StringRef(WithoutToken).find('^') == StringRef::npos &&
          "expected exactly one completion token ^ inside the code");
 
   auto Action = llvm::make_unique<CodeCompleteAction>(
-      offsetToPosition(WithoutToken, TokenOffset), Results);
+      offsetToPosition(WithoutToken, TokenOffset), CCOpts, Results);
   clang::tooling::runToolOnCodeWithArgs(Action.release(), Code, {"-std=c++11"},
                                         TestCCName);
   return Results;
 }
 
 TEST(SemaCodeCompleteTest, VisitedNSForValidQualifiedId) {
   auto VisitedNS = runCodeCompleteOnCode(R"cpp(
      namespace ns1 {}

 
 TEST(SemaCodeCompleteTest, VisitedNSForInvalideQualifiedId) {
   auto VisitedNS = runCodeCompleteOnCode(R"cpp(
      namespace ns { foo::^ }
   )cpp");
   EXPECT_TRUE(VisitedNS.empty());
 }
 
+TEST(SemaCodeCompleteTest, DisableTypoCorrection) {
+  CodeCompleteOptions CCOpts;
+  CCOpts.DisableTypoCorrection = 1;
+  auto VisitedNS = runCodeCompleteOnCode(R"cpp(
+     namespace clang {}
+     clangd::^
+  )cpp", CCOpts);
+  EXPECT_TRUE(VisitedNS.empty());
+}
+
 } // namespace