Index: include/clang/AST/Type.h
===================================================================
--- include/clang/AST/Type.h
+++ include/clang/AST/Type.h
@@ -3374,6 +3374,7 @@
 
 public:
   TagDecl *getDecl() const;
+  TagDecl *getDecl();
 
   /// @brief Determines whether this type is in the process of being
   /// defined.
Index: lib/AST/Type.cpp
===================================================================
--- lib/AST/Type.cpp
+++ lib/AST/Type.cpp
@@ -1895,6 +1895,10 @@
   return getInterestingTagDecl(decl);
 }
 
+TagDecl *TagType::getDecl() {
+  return getInterestingTagDecl(decl);
+}
+
 bool TagType::isBeingDefined() const {
   return getDecl()->isBeingDefined();
 }
Index: lib/Sema/SemaDecl.cpp
===================================================================
--- lib/Sema/SemaDecl.cpp
+++ lib/Sema/SemaDecl.cpp
@@ -128,45 +128,82 @@
   return false;
 }
 
+namespace {
+enum BasesLookupResult { NotFound, FoundNotType, FoundType };
+} // namespace
+
+/// \brief Tries to perform unqualified lookup of the type decls in bases for
+/// dependent class.
+/// \return \a NotFound if no any decls is found, \a FoundNotType if found not a
+/// type decl, \a FoundType if only type decls are found.
+static BasesLookupResult lookupInBases(Sema &S, const IdentifierInfo &II,
+                                       SourceLocation NameLoc,
+                                       const CXXRecordDecl *RD) {
+  if (!RD || !RD->getDescribedClassTemplate())
+    return NotFound;
+
+  // Look for type decls in base classes.
+  BasesLookupResult FoundTypeDecl = NotFound;
+  for (const auto &Base : RD->bases()) {
+    if (auto *TT = Base.getType()->getAs<TagType>()) {
+      // Look for type decls in non-dependent base classes.
+      if (auto *DC = dyn_cast<DeclContext>(TT->getDecl())) {
+        LookupResult LR(S, DeclarationName(&II), NameLoc,
+                        /*LookupKind=*/Sema::LookupAnyName);
+        if (!S.LookupQualifiedName(LR, DC) &&
+            LR.getResultKind() == LookupResult::NotFound)
+          continue;
+        if (!LR.getAsSingle<TypeDecl>())
+          return FoundNotType;
+        FoundTypeDecl = FoundType;
+      }
+    } else if (auto *TST =
+                   Base.getType()->getAs<TemplateSpecializationType>()) {
+      // Look for type decls in dependent base classes that have known primary
+      // templates.
+      if (!TST || !TST->isDependentType())
+        continue;
+      auto *TD = TST->getTemplateName().getAsTemplateDecl();
+      if (!TD)
+        continue;
+      auto *BasePrimaryTemplate =
+          dyn_cast_or_null<CXXRecordDecl>(TD->getTemplatedDecl());
+      if (!BasePrimaryTemplate)
+        continue;
+      switch (lookupInBases(S, II, NameLoc, BasePrimaryTemplate)) {
+      case FoundNotType:
+        return FoundNotType;
+      case FoundType:
+        FoundTypeDecl = FoundType;
+        break;
+      case NotFound:
+        break;
+      }
+      for (NamedDecl *ND : BasePrimaryTemplate->lookup(&II)) {
+        if (!isa<TypeDecl>(ND))
+          return FoundNotType;
+        FoundTypeDecl = FoundType;
+      }
+    }
+  }
+
+  return FoundTypeDecl;
+}
+
 static ParsedType recoverFromTypeInKnownDependentBase(Sema &S,
                                                       const IdentifierInfo &II,
                                                       SourceLocation NameLoc) {
   // Find the first parent class template context, if any.
-  // FIXME: Perform the lookup in all enclosing class templates.
   const CXXRecordDecl *RD = nullptr;
   for (DeclContext *DC = S.CurContext; DC; DC = DC->getParent()) {
     RD = dyn_cast<CXXRecordDecl>(DC);
     if (RD && RD->getDescribedClassTemplate())
       break;
   }
-  if (!RD)
-    return ParsedType();
-
   // Look for type decls in dependent base classes that have known primary
   // templates.
-  bool FoundTypeDecl = false;
-  for (const auto &Base : RD->bases()) {
-    auto *TST = Base.getType()->getAs<TemplateSpecializationType>();
-    if (!TST || !TST->isDependentType())
-      continue;
-    auto *TD = TST->getTemplateName().getAsTemplateDecl();
-    if (!TD)
-      continue;
-    auto *BasePrimaryTemplate =
-        dyn_cast_or_null<CXXRecordDecl>(TD->getTemplatedDecl());
-    if (!BasePrimaryTemplate)
-      continue;
-    // FIXME: Allow lookup into non-dependent bases of dependent bases, possibly
-    // by calling or integrating with the main LookupQualifiedName mechanism.
-    for (NamedDecl *ND : BasePrimaryTemplate->lookup(&II)) {
-      if (FoundTypeDecl)
-        return ParsedType();
-      FoundTypeDecl = isa<TypeDecl>(ND);
-      if (!FoundTypeDecl)
-        return ParsedType();
-    }
-  }
-  if (!FoundTypeDecl)
+  BasesLookupResult FoundTypeDecl = lookupInBases(S, II, NameLoc, RD);
+  if (FoundTypeDecl != FoundType)
     return ParsedType();
 
   // We found some types in dependent base classes.  Recover as if the user
Index: test/SemaTemplate/ms-lookup-template-base-classes.cpp
===================================================================
--- test/SemaTemplate/ms-lookup-template-base-classes.cpp
+++ test/SemaTemplate/ms-lookup-template-base-classes.cpp
@@ -303,12 +303,12 @@
 }
 
 namespace two_types_in_base {
-template <typename T> struct A { typedef T NameFromBase; };
-template <typename T> struct B { struct NameFromBase { T m; }; };
+template <typename T> struct A { typedef T NameFromBase; }; // expected-note {{member found by ambiguous name lookup}}
+template <typename T> struct B { struct NameFromBase { T m; }; }; // expected-note {{member found by ambiguous name lookup}}
 template <typename T> struct C : A<T>, B<T> {
-  NameFromBase m; // expected-error {{unknown type name 'NameFromBase'}}
+  NameFromBase m; // expected-error {{member 'NameFromBase' found in multiple base classes of different types}} expected-warning {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
 };
-static_assert(sizeof(C<int>) == 4, "");
+static_assert(sizeof(C<int>) == 4, ""); // expected-note {{in instantiation of template class 'two_types_in_base::C<int>' requested here}}
 }
 
 namespace type_and_decl_in_base {
@@ -386,9 +386,28 @@
 struct A { typedef int NameFromBase; };
 template <typename T>
 struct B : A {};
-// FIXME: MSVC accepts this.
 template <typename T>
-struct C : B<T> { NameFromBase m; }; // expected-error {{unknown type name 'NameFromBase'}}
+struct C : B<T> { NameFromBase m; }; // expected-warning {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
+}
+
+namespace type_in_virtual_base_of_dependent_base {
+template <typename T>
+struct A { typedef T NameFromBase; };
+template <typename T>
+struct B : virtual A<T> {};
+template <typename T>
+struct C : B<T>, virtual A<T> { NameFromBase m; }; // expected-warning {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
+C<int> c;
+}
+
+namespace type_in_base_of_multiple_dependent_bases {
+template <typename T>
+struct A { typedef T NameFromBase; };
+template <typename T>
+struct B : public A<T> {};
+template <typename T>
+struct C : B<T>, public A<T> { NameFromBase m; }; // expected-warning {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}} expected-warning {{direct base 'A<int>' is inaccessible due to ambiguity:}}
+C<int> c; // expected-note {{in instantiation of template class 'type_in_base_of_multiple_dependent_bases::C<int>' requested here}}
 }
 
 namespace lookup_in_function_contexts {