[Sema] Don't display an invalid redefinition error when dealing with a redefinition of a function whose previous definition was typo-corrected

[arphaman]

Summary

This patch improves the displayed diagnostics when encountering a redefinition of a function whose previous definition was typo-corrected.

For example, given a code sample like this:

class Foo {
  int* create_process(int pid, const char* name);
};

int *Foo::create_process2(int pid, const char* name) {
  return 0;
}

int *Foo::create_process(int pid, const char* name) {
  return 0;
}

Clang will now show only the error diagnostic for the definition of create_process2: "out-of-line definition of 'create_process2' does not match any declaration in 'Foo'; did you mean 'create_process'?". However, prior to this patch, clang would have also shown a second error diagnostic for the definition of create_process: "redefinition of 'create_process'". The second diagnostic shouldn't be presented as it's not true, and the automatic renaming of create_process2 shouldn't cause such an error.

[arphaman]

Rebased the patch.

[v.g.vassilev]

LGTM!

cfe/trunk/include/clang/Sema/Sema.h

public:
 
   typedef std::pair<CXXRecordDecl*, CXXSpecialMember> SpecialMemberDecl;
 
   /// The C++ special members which we are currently in the process of
   /// declaring. If this process recursively triggers the declaration of the
   /// same special member, we should act as if it is not yet declared.
   llvm::SmallSet<SpecialMemberDecl, 4> SpecialMembersBeingDeclared;
 
+  /// The function definitions which were renamed as part of typo-correction
+  /// to match their respective declarations. We want to keep track of them
+  /// to ensure that we don't emit a "redefinition" error if we encounter a
+  /// correctly named definition after the renamed definition.
+  llvm::SmallPtrSet<const NamedDecl *, 4> TypoCorrectedFunctionDefinitions;
+
   void ReadMethodPool(Selector Sel);
   void updateOutOfDateSelector(Selector Sel);
 
   /// Private Helper predicate to check for 'self'.
   bool isSelfExpr(Expr *RExpr);
   bool isSelfExpr(Expr *RExpr, const ObjCMethodDecl *Method);
 
   /// \brief Cause the active diagnostic on the DiagosticsEngine to be
void diagnoseTypo(const TypoCorrection &Correction,
                     const PartialDiagnostic &TypoDiag,
                     bool ErrorRecovery = true);
 
   void diagnoseTypo(const TypoCorrection &Correction,
                     const PartialDiagnostic &TypoDiag,
                     const PartialDiagnostic &PrevNote,
                     bool ErrorRecovery = true);
 
+  void MarkTypoCorrectedFunctionDefinition(const NamedDecl *F);
+
   void FindAssociatedClassesAndNamespaces(SourceLocation InstantiationLoc,
                                           ArrayRef<Expr *> Args,
                                    AssociatedNamespaceSet &AssociatedNamespaces,
                                    AssociatedClassSet &AssociatedClasses);
 
   void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S,
                             bool ConsiderLinkage, bool AllowInlineNamespace);
 

cfe/trunk/lib/Sema/SemaDecl.cpp

  private:
   ASTContext &Context;
   FunctionDecl *OriginalFD;
   CXXRecordDecl *ExpectedParent;
 };
 
 } // end anonymous namespace
 
+void Sema::MarkTypoCorrectedFunctionDefinition(const NamedDecl *F) {
+  TypoCorrectedFunctionDefinitions.insert(F);
+}
+
 /// \brief Generate diagnostics for an invalid function redeclaration.
 ///
 /// This routine handles generating the diagnostic messages for an invalid
 /// function redeclaration, including finding possible similar declarations
 /// or performing typo correction if there are no previous declarations with
 /// the same name.
 ///
 /// Returns a NamedDecl iff typo correction was performed and substituting in
// If the qualified name lookup yielded nothing, try typo correction
     if (Result) {
       // Determine which correction we picked.
       Decl *Canonical = Result->getCanonicalDecl();
       for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
            I != E; ++I)
         if ((*I)->getCanonicalDecl() == Canonical)
           Correction.setCorrectionDecl(*I);
 
+      // Let Sema know about the correction.
+      SemaRef.MarkTypoCorrectedFunctionDefinition(Result);
       SemaRef.diagnoseTypo(
           Correction,
           SemaRef.PDiag(IsLocalFriend
                           ? diag::err_no_matching_local_friend_suggest
                           : diag::err_member_decl_does_not_match_suggest)
             << Name << NewDC << IsDefinition);
       return Result;
     }
Sema::CheckForFunctionRedefinition(FunctionDecl *FD,
   const FunctionDecl *Definition = EffectiveDefinition;
   if (!Definition)
     if (!FD->isDefined(Definition))
       return;
 
   if (canRedefineFunction(Definition, getLangOpts()))
     return;
 
+  // Don't emit an error when this is redifinition of a typo-corrected
+  // definition.
+  if (TypoCorrectedFunctionDefinitions.count(Definition))
+    return;
+
   // If we don't have a visible definition of the function, and it's inline or
   // a template, skip the new definition.
   if (SkipBody && !hasVisibleDefinition(Definition) &&
       (Definition->getFormalLinkage() == InternalLinkage ||
        Definition->isInlined() ||
        Definition->getDescribedFunctionTemplate() ||
        Definition->getNumTemplateParameterLists())) {
     SkipBody->ShouldSkip = true;

cfe/trunk/test/SemaCXX/typo-correction.cpp

 namespace {
 struct a0is0 {};
 struct b0is0 {};
 int g() {
   0 [                 // expected-error {{subscripted value is not an array}}
       sizeof(c0is0)]; // expected-error {{use of undeclared identifier}}
 };
 }
+
+namespace avoidRedundantRedefinitionErrors {
+class Class {
+  void function(int pid); // expected-note {{'function' declared here}}
+};
+
+void Class::function2(int pid) { // expected-error {{out-of-line definition of 'function2' does not match any declaration in 'avoidRedundantRedefinitionErrors::Class'; did you mean 'function'?}}
+}
+
+// Expected no redefinition error here.
+void Class::function(int pid) { // expected-note {{previous definition is here}}
+}
+
+void Class::function(int pid) { // expected-error {{redefinition of 'function'}}
+}
+
+namespace ns {
+void create_test(); // expected-note {{'create_test' declared here}}
+}
+
+void ns::create_test2() { // expected-error {{out-of-line definition of 'create_test2' does not match any declaration in namespace 'avoidRedundantRedefinitionErrors::ns'; did you mean 'create_test'?}}
+}
+
+// Expected no redefinition error here.
+void ns::create_test() {
+}
+}