Add missing cases to FunctionDecl::isThisDeclarationADefinition

[sepavloff]

Summary

This change adds to the method isThisDeclarationADefinition additional
conditions under which a function declaration becomes a definition.
These includes the case of a declaration that does not have a function
body because the latter is not instantiated yet.

[sepavloff]

These changes are incorporated into D30170.

include/clang/AST/Decl.h

public:
   /// unnecessary AST de-serialization of the body.
   Stmt *getBody(const FunctionDecl *&Definition) const;
 
   Stmt *getBody() const override {
     const FunctionDecl* Definition;
     return getBody(Definition);
   }
 
-  /// isThisDeclarationADefinition - Returns whether this specific
-  /// declaration of the function is also a definition. This does not
-  /// determine whether the function has been defined (e.g., in a
-  /// previous definition); for that information, use isDefined. Note
-  /// that this returns false for a defaulted function unless that function
-  /// has been implicitly defined (possibly as deleted).
+  /// Returns whether this specific declaration of the function is also
+  /// a definition.
+  ///
+  /// The method checks for definiteness of the declaration in the sense, used
+  /// in redefinition checks. A defined function usually cannot have more than
+  /// one definition. At the same time it may have its body absent, for instance,
+  /// because it does not exist at all as in deleted functions, or is not
+  /// instantiated yet as in templated entities. Corresponding declarations are
+  /// also reported as definitions.
+  ///
+  /// This does not determine whether the function has been defined (e.g., in a
+  /// previous definition); for that information, use isDefined.
+  ///
   bool isThisDeclarationADefinition() const {
-    return IsDeleted || Body || IsLateTemplateParsed;
+    if (IsDeleted || IsDefaulted || Body || IsLateTemplateParsed ||
+        hasDefiningAttr())
+      return true;
+    if (FunctionDecl *Original = getInstantiatedFromMemberFunction())
+      return Original->isThisDeclarationADefinition();
+    return false;
   }
 
   /// doesThisDeclarationHaveABody - Returns whether this specific
   /// declaration of the function has a body - that is, if it is a non-
   /// deleted definition.
   bool doesThisDeclarationHaveABody() const {
     return Body || IsLateTemplateParsed;
   }

test/SemaCXX/cxx0x-cursory-default-delete.cpp

 struct bad_decls {
   bad_decls(volatile bad_decls&) = default; // expected-error {{may not be volatile}}
   bad_decls&& operator = (bad_decls) = default; // expected-error {{lvalue reference}} expected-error {{must return 'bad_decls &'}}
   bad_decls& operator = (volatile bad_decls&) = default; // expected-error {{may not be volatile}}
   bad_decls& operator = (const bad_decls&) const = default; // expected-error {{may not have 'const', 'constexpr' or 'volatile' qualifiers}}
 };
 
 struct DefaultDelete {
-  DefaultDelete() = default; // expected-note {{previous declaration is here}}
+  DefaultDelete() = default; // expected-note {{previous definition is here}}
   DefaultDelete() = delete; // expected-error {{constructor cannot be redeclared}}
 
-  ~DefaultDelete() = default; // expected-note {{previous declaration is here}}
+  ~DefaultDelete() = default; // expected-note {{previous definition is here}}
   ~DefaultDelete() = delete; // expected-error {{destructor cannot be redeclared}}
 
-  DefaultDelete &operator=(const DefaultDelete &) = default; // expected-note {{previous declaration is here}}
+  DefaultDelete &operator=(const DefaultDelete &) = default; // expected-note {{previous definition is here}}
   DefaultDelete &operator=(const DefaultDelete &) = delete; // expected-error {{class member cannot be redeclared}}
 };
 
 struct DeleteDefault {
   DeleteDefault() = delete; // expected-note {{previous definition is here}}
   DeleteDefault() = default; // expected-error {{constructor cannot be redeclared}}
 
   ~DeleteDefault() = delete; // expected-note {{previous definition is here}}