[MSVC] Better lookup into dependent bases for unspecified declaration (also fixes http://llvm.org/PR22066)

[ABataev]

Summary

Provides better qualified/unqualified lookup into dependent bases for MSVC code + improves diagnostics.

[rnk]

I'm still not 100% sure what's going on here. In particular, I'd like to better understand the meaning of IdNameLookupResult.

Do you think you can split out a small change that adds the "insert typename here" suggestions? That would be a mostly mechanical change to update test results that significantly reduces the diff.

include/clang/Sema/Sema.h

3518

Nobody in Parse calls this, so this can be QualType instead of ParsedType.

3519

In this change, all call sites pass all of these parameters. Can you drop the default values?

lib/Sema/SemaDecl.cpp

150–161

This needs editing. I think you might be better off documenting each IdNameLookupResult individually.

155

I think we can use a simple function pointer without using too much power. Alternatively, llvm::function_ref is lighter weight.

263–270

Looks like you can hoist the NonInstanceMemberOnly check out, and then remove the need for std::function. Consider:

if (NonInstanceMemberOnly)
  return isDeclInDependentClass(
      *this, SS, Loc, II, SupposeExistInBaseParm, [](NamedDecl *ND) {
        return ND->isCXXClassMember() && !ND->isCXXInstanceMember();
      });
return isDeclInDependentClass(
    *this, SS, Loc, II, SupposeExistInBaseParm,
    [](NamedDecl *ND) { return ND->isCXXClassMember(); });

lib/Sema/SemaExpr.cpp

1959

These conditions are equivalent, right? This can be if (ObjectType)

1989

Ditto, !ObjectType && SS && SS->isEmpty()

2105–2123

No need to use doxygen style /// comments in a function

[ABataev]

Reid, I will remove all 'typename' related code.

include/clang/Sema/Sema.h

3518

Fixed

3519

Ok

lib/Sema/SemaDecl.cpp

150–161

Added an additional comment about SupposeFoundSpecifiedKind element and added comments to IdNameLookupResult enum and its elements.

155

Changed it to function_ref

263–270

Ok, consider it done

lib/Sema/SemaExpr.cpp

1959

Fixed

1989

Fixed

2105–2123

Ok, fixed

[ABataev]

Update after review

[ABataev]

Ping!

[rnk]

I think this is pretty close to done, but I want to get an opinion from Richard before committing, since he's more familiar with lookup.

lib/Sema/SemaDecl.cpp

139–142

OK, this is sort of the case being described:

template <typename T> struct Foo : T { void f(int a) { IdFromBase(a); } };

I think we need better terminology to talk about how this case differs from this case:

template <typename T> struct Foo : Bar<T> { ... };

Both of these are classes with dependent bases, but in the second case, we can go searching through the template pattern for Bar to try to see if it has type or non-type members. I think if we can come up with a name for one of these two cases, we can make this code a lot clearer.

We should get Richard's input on this, but here are some ideas:

• Fully dependent / partially dependent
• Dependent base with known pattern / unknown dependent base

So far, I like using the "known / unknown pattern" terminology best, so I might rename this enumerator to NotFoundWithUnknownBase. This indicates that after doing extended lookup into dependent bases with known patterns, no members with this name were found, but we hit an unknown base that we couldn't look through.

157

If we go with this "known / unknown" terminology, this can be lookupIdInKnownDependentClass or something.

170

This can be an early return:

if (FoundDecl != IdNameLookupResult::NotFound)
  return FoundDecl;

195

This can also continue early:

if (!BaseRD)
  continue;

220

This is still std::function

[ABataev]

Reid, thanks for the review!

lib/Sema/SemaDecl.cpp

139–142

Yep, you're right. I also prefer "known / unknown pattern". I'll rename the enumerator.

170

Ok, fixed

195

Fixed

220

Fixed

[ABataev]

Update after review

[rsmith]

include/clang/Sema/Sema.h

3500–3518

From reading this alone, I have very little idea what this function does.

lib/Sema/SemaDecl.cpp

137–144

I don't think you mean 'type' here. Also remove the 'If'.

139

Remove 'is'.

140

Why only of that type? Why not any dependent type that we can't heuristically look into?

143

Again, 'type' seems wrong here. 'kind' perhaps?

148–150

How about something like "Attempt to determine what lookup of a name would find in an instantiation of a dependent class. For a dependent base class, we make a heuristic guess as to the template from which the base class will be instantiated."

157

IdName doesn't really mean anything. Drop the Id here? Also, this name suggests that we're doing a normal lookup into a dependent class, following standard rules, and producing a list of declarations, which isn't correct.

Something like classifyNameInKnownDependentBases might be a better name.

158

This interface would make more sense if it took a DeclarationName rather than a const IdentifierInfo &.

159

Maybe something like AssumeExistsInUnknownDependentBase would be clearer than SupposeExistInBaseParm? But this flag seems to be unnecessary -- instead, the callers can distinguish between NotFound and NotFoundWithUnknownBase, or not, as necessary.

163–164

The getCanonicalType call here appears to be redundant.

163–164

Comment seems out of date.

164–165

This seems like a strange case to treat specially. Why would you handle a base class of type T here but not a base class of type T::type? (Why don't we do this for all dependent base classes that we can't heuristically perform lookup into?)

165

You should probably use ND->getUnderlyingDecl() here to handle using-declarations.

165–166

If we find a type and a non-type, the type should win, per [basic.scope.declarative]p4 bullet 2.

218

Again, "dependent class" isn't the right term here, because normal lookup in a class template definition looks for names in a dependent class.

218

Please keep the parameter order consistent between this class and the previous one. Putting the class name / scope specifier before the name being looked up seems like the better order.

225–226

This doesn't look right. If I have

template<typename T> struct X { typedef T type; };

then lookup of type within X<T*>:: should presumably look in the primary template for X rather than looking in the current context.

228

This should be DC->getLookupParent().

232

This requires RD to be the pattern of a class template; I would think that class template partial specializations, member classes of class templates, and local classes within function templates should get the same handling. You can just check RD->isDependentContext() to catch all of those cases.

238–244

It's very strange for a function that looks like a simple predicate to modify its arguments in-place like this. How about making this function return a NestedNameSpecifier * or CXXRecordDecl * instead?

251

Can we somehow suggest in this name that the answer is uncertain if we don't know what all the dependent bases look like? isClassTemplateInKnownDependentBase perhaps?

255

Should we allow other type templates, such as AliasTemplateDecl here too?

287–292

Why don't we emit a diagnostic here for qualified lookup?

393–394

Comment seems out of date.

826–827

Comment seems out of date.

lib/Sema/SemaExpr.cpp

1959

Please remove 'cxx' from the comments here.

1988–1993

A function named is... should not be mutating state and producing diagnostics like this. Can you move the actual recovery code into the caller, or rename this function to reflect what it does (recoverFromUnknownMemberLookup or something)?

2105–2122

"class template", not "template class", "base class" not "parent class". Also, don't you mean "if we're inside a class template that has dependent base classes"?

2112–2122

The checking performed here should depend on whether this is available. When walking the current class and its base classes, you're allowed to find members that need this and members that don't, but when you recurse to surrounding scopes, you should stop allowing members that need this.

lib/Sema/SemaTemplate.cpp

184–186

This is a weird fixit: it's not syntactically vaild to put typename there. Do we really suggest that?

test/SemaCXX/MicrosoftCompatibility.cpp

169–176

Why do we no longer give these warnings?

test/SemaTemplate/typename-specifier.cpp

214–216

Shouldn't there be a warning here for the MSVC case?

include/clang/Basic/DiagnosticSemaKinds.td

 def err_undeclared_var_use : Error<"use of undeclared identifier %0">;
 def ext_undeclared_unqual_id_with_dependent_base : ExtWarn<
   "use of undeclared identifier %0; "
   "unqualified lookup into dependent bases of class template %1 is a Microsoft extension">,
   InGroup<Microsoft>;
 def ext_found_via_dependent_bases_lookup : ExtWarn<"use of identifier %0 "
   "found via unqualified lookup into dependent bases of class templates is a "
   "Microsoft extension">, InGroup<Microsoft>;
+def ext_found_via_dependent_base_lookup : ExtWarn<"use of identifier %0 "
+  "found via unqualified lookup into dependent bases of class template %1 is a "
+  "Microsoft extension">, InGroup<Microsoft>;
 def note_dependent_var_use : Note<"must qualify identifier to find this "
     "declaration in dependent base class">;
 def err_not_found_by_two_phase_lookup : Error<"call to function %0 that is neither "
     "visible in the template definition nor found by argument-dependent lookup">;
 def note_not_found_by_two_phase_lookup : Note<"%0 should be declared prior to the "
     "call site%select{| or in %2| or in an associated namespace of one of its arguments}1">;
 def err_undeclared_use : Error<"use of undeclared %0">;
 def warn_deprecated : Warning<"%0 is deprecated">,

include/clang/Sema/Sema.h

public:
   /// reachability analysis to determine if the statement is reachable.
   /// If it is unreachable, the diagnostic will not be emitted.
   bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement,
                            const PartialDiagnostic &PD);
 
   // Primary Expressions.
   SourceRange getExprRange(Expr *E) const;
 
+  /// \brief Checks if currently looking for symbols in a class with dependent
+  /// bases. Used in Microsoft Compatibility mode for better compatibility
+  /// during lookup into classes with dependent bases.
+  /// \param LastChanceToRecover true if no need to check for decl existence in
+  /// base dependent classes, false if still need to check.
+  /// \param SS If not nullptr and not empty the base class is calculated from
+  /// this scope. If not nullptr and empty and \a ObjectType is empty then it is
+  /// calculated in this method from the current context.
+  /// \param ObjectType If specified the base class is calculated from this
+  /// type.
+  /// \param II Used for diagnostic only. If \a SS is not nullptr and empty and
+  /// \a ObjectType is empty and \a is not nullptr \a SS is calculated and a
+  /// diagnostic is emitted.
+  /// \return true if currently trying to lookup in class with the dependent
+  /// base, false otherwise.
+  bool isInClassWithAnyDependentBase(SourceLocation Loc,
+                                     bool IsLastChanceToRecover,
+                                     CXXScopeSpec *SS, QualType ObjectType,
+                                     const IdentifierInfo *II);
+
+  /// \brief Checks if the specified identifier \a II is a class template
+  /// declaration declared in a class with dependent bases (specified in \a SS
+  /// scope).
+  bool isClassTemplateInClassWithAnyDependentBase(CXXScopeSpec &SS,
+                                                  SourceLocation Loc,
+                                                  const IdentifierInfo &II);
+
+  /// \brief Checks if the specified identifier \a II is any member declared in
+  /// a class with dependent bases (specified in \a SS scope).
+  bool isMemberInClassWithAnyDependentBase(CXXScopeSpec &SS, SourceLocation Loc,
+                                           const IdentifierInfo &II,
+                                           bool NonInstanceMemberOnly,
+                                           bool SupposeExistInBaseParm);
+
   ExprResult ActOnIdExpression(
       Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
       UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand,
       std::unique_ptr<CorrectionCandidateCallback> CCC = nullptr,
       bool IsInlineAsmIdentifier = false, Token *KeywordReplacement = nullptr);
 
   void DecomposeUnqualifiedId(const UnqualifiedId &Id,
                               TemplateArgumentListInfo &Buffer,

lib/Sema/SemaDecl.cpp

bool Sema::isSimpleTypeSpecifier(tok::TokenKind Kind) const {
   default:
     break;
   }
 
   return false;
 }
 
 namespace {
-enum class UnqualifiedTypeNameLookupResult {
+/// \brief Result of lookup for members with the specified identifier into a
+/// class with any dependent base.
+enum class IdNameLookupResult {
+  /// \brief No members found at all.
   NotFound,
-  FoundNonType,
-  FoundType
+  /// \brief If found a member, but its type does not match the expected one.
+  FoundNotSpecifiedKind,
+  /// \brief There are no members is found, but class has a base of class
+  /// TemplateTypeParmType and we are allowed to suppose that the specified
+  /// identifier may be a member of this base.
+  SupposeFoundSpecifiedKind,
+  /// \brief Found a member of the expected type.
+  FoundSpecifiedKind,
 };
 } // namespace
 
-/// \brief Tries to perform unqualified lookup of the type decls in bases for
+/// \brief Tries to perform unqualified lookup of the 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 UnqualifiedTypeNameLookupResult
-lookupUnqualifiedTypeNameInBase(Sema &S, const IdentifierInfo &II,
-                                SourceLocation NameLoc,
-                                const CXXRecordDecl *RD) {
+/// \return \a NotFound if no any decls is found, \a FoundNotSpecifiedKind if
+/// found a decl of different type, \a FoundSpecifiedKind if only decls of the
+/// expected types are found. If \a SupposeExistInBaseParm is true and one of
+/// the base classes is a TemplateTypeParmType then it is supposed that the
+/// specified identifier may be a field of that base class. If there are no
+/// other identifiers is found, \a SupposeFoundSpecifiedKind is returned in this
+/// case.
+static IdNameLookupResult lookupIdNameInDependentClass(
+    Sema &S, const IdentifierInfo &II, SourceLocation NameLoc,
+    const CXXRecordDecl *RD, bool SupposeExistInBaseParm,
+    const llvm::function_ref<bool(NamedDecl *)> &CheckKind) {
   if (!RD->hasDefinition())
-    return UnqualifiedTypeNameLookupResult::NotFound;
+    return IdNameLookupResult::NotFound;
   // Look for type decls in base classes.
-  UnqualifiedTypeNameLookupResult FoundTypeDecl =
-      UnqualifiedTypeNameLookupResult::NotFound;
+  IdNameLookupResult FoundDecl = IdNameLookupResult::NotFound;
+  for (NamedDecl *ND : RD->lookup(&II)) {
+    if (!CheckKind(ND))
+      return IdNameLookupResult::FoundNotSpecifiedKind;
+    FoundDecl = IdNameLookupResult::FoundSpecifiedKind;
+  }
+  if (FoundDecl == IdNameLookupResult::NotFound) {
     for (const auto &Base : RD->bases()) {
       const CXXRecordDecl *BaseRD = nullptr;
-    if (auto *BaseTT = Base.getType()->getAs<TagType>())
+      auto BaseTy = S.getASTContext().getCanonicalType(Base.getType());
+      if (const TagType *BaseTT = BaseTy->getAs<TagType>())
         BaseRD = BaseTT->getAsCXXRecordDecl();
-    else if (auto *TST = Base.getType()->getAs<TemplateSpecializationType>()) {
+      else if (const TemplateSpecializationType *TST =
+                   BaseTy->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;
         BaseRD = BasePrimaryTemplate;
+      } else if (SupposeExistInBaseParm &&
+                 BaseTy->getAs<TemplateTypeParmType>() &&
+                 FoundDecl == IdNameLookupResult::NotFound) {
+        FoundDecl = IdNameLookupResult::SupposeFoundSpecifiedKind;
       }
       if (BaseRD) {
-      for (NamedDecl *ND : BaseRD->lookup(&II)) {
-        if (!isa<TypeDecl>(ND))
-          return UnqualifiedTypeNameLookupResult::FoundNonType;
-        FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
-      }
-      if (FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound) {
-        switch (lookupUnqualifiedTypeNameInBase(S, II, NameLoc, BaseRD)) {
-        case UnqualifiedTypeNameLookupResult::FoundNonType:
-          return UnqualifiedTypeNameLookupResult::FoundNonType;
-        case UnqualifiedTypeNameLookupResult::FoundType:
-          FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
+        switch (lookupIdNameInDependentClass(
+            S, II, NameLoc, BaseRD, SupposeExistInBaseParm, CheckKind)) {
+        case IdNameLookupResult::FoundNotSpecifiedKind:
+          return IdNameLookupResult::FoundNotSpecifiedKind;
+        case IdNameLookupResult::FoundSpecifiedKind:
+          FoundDecl = IdNameLookupResult::FoundSpecifiedKind;
           break;
-        case UnqualifiedTypeNameLookupResult::NotFound:
+        case IdNameLookupResult::SupposeFoundSpecifiedKind:
+          if (FoundDecl == IdNameLookupResult::NotFound)
+            FoundDecl = IdNameLookupResult::SupposeFoundSpecifiedKind;
+          break;
+        case IdNameLookupResult::NotFound:
           break;
         }
       }
     }
   }
 
-  return FoundTypeDecl;
+  return FoundDecl;
 }
 
-static ParsedType recoverFromTypeInKnownDependentBase(Sema &S,
-                                                      const IdentifierInfo &II,
-                                                      SourceLocation NameLoc) {
+static bool
+isDeclInDependentClass(Sema &S, CXXScopeSpec &SS, SourceLocation Loc,
+                       const IdentifierInfo &II, bool SupposeExistInBaseParm,
+                       const std::function<bool(NamedDecl *)> &CheckKind) {
   // Lookup in the parent class template context, if any.
   const CXXRecordDecl *RD = nullptr;
-  UnqualifiedTypeNameLookupResult FoundTypeDecl =
-      UnqualifiedTypeNameLookupResult::NotFound;
-  for (DeclContext *DC = S.CurContext;
-       DC && FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound;
+  IdNameLookupResult FoundDecl = IdNameLookupResult::NotFound;
+  auto *DC = S.computeDeclContext(SS, /*EnteringContext=*/true);
+  if (!DC)
+    DC = S.CurContext;
+  for (; DC && FoundDecl == IdNameLookupResult::NotFound;
        DC = DC->getParent()) {
     // Look for type decls in dependent base classes that have known primary
     // templates.
     RD = dyn_cast<CXXRecordDecl>(DC);
     if (RD && RD->getDescribedClassTemplate())
-      FoundTypeDecl = lookupUnqualifiedTypeNameInBase(S, II, NameLoc, RD);
-  }
-  if (FoundTypeDecl != UnqualifiedTypeNameLookupResult::FoundType)
+      FoundDecl = lookupIdNameInDependentClass(
+          S, II, Loc, RD, SupposeExistInBaseParm, CheckKind);
+  }
+  if (FoundDecl == IdNameLookupResult::FoundSpecifiedKind ||
+      FoundDecl == IdNameLookupResult::SupposeFoundSpecifiedKind) {
+    if (SS.isEmpty()) {
+      auto *NNS =
+          NestedNameSpecifier::Create(S.getASTContext(),
+                                      /*Prefix=*/nullptr,
+                                      /*Template=*/false, RD->getTypeForDecl());
+      SS.MakeTrivial(S.getASTContext(), NNS, SourceRange(Loc, Loc));
+    }
+    return true;
+  }
+
+  return false;
+}
+
+bool Sema::isClassTemplateInClassWithAnyDependentBase(
+    CXXScopeSpec &SS, SourceLocation Loc, const IdentifierInfo &II) {
+  return isDeclInDependentClass(
+      *this, SS, Loc, II, /*SupposeExistInBaseParm=*/false,
+      [](NamedDecl *ND) -> bool { return isa<ClassTemplateDecl>(ND); });
+}
+
+bool Sema::isMemberInClassWithAnyDependentBase(CXXScopeSpec &SS,
+                                               SourceLocation Loc,
+                                               const IdentifierInfo &II,
+                                               bool NonInstanceMemberOnly,
+                                               bool SupposeExistInBaseParm) {
+  if (NonInstanceMemberOnly)
+    return isDeclInDependentClass(
+        *this, SS, Loc, II, SupposeExistInBaseParm, [](NamedDecl *ND) {
+          return ND->isCXXClassMember() && !ND->isCXXInstanceMember();
+        });
+  return isDeclInDependentClass(
+      *this, SS, Loc, II, SupposeExistInBaseParm,
+      [](NamedDecl *ND) { return ND->isCXXClassMember(); });
+
+static ParsedType recoverFromTypeInKnownDependentBase(Sema &S,
+                                                      CXXScopeSpec &SS,
+                                                      const IdentifierInfo &II,
+                                                      SourceLocation NameLoc) {
+  bool IsUnqualifiedLookup = SS.isEmpty();
+  if (!isDeclInDependentClass(
+          S, SS, NameLoc, II, /*SupposeExistInBaseParm=*/false,
+          [](NamedDecl *ND) -> bool { return isa<TypeDecl>(ND); }))
     return ParsedType();
 
   // We found some types in dependent base classes.  Recover as if the user
   // wrote 'typename MyClass::II' instead of 'II'.  We'll fully resolve the
   // lookup during template instantiation.
-  S.Diag(NameLoc, diag::ext_found_via_dependent_bases_lookup) << &II;
-
   ASTContext &Context = S.Context;
-  auto *NNS = NestedNameSpecifier::Create(Context, nullptr, false,
-                                          cast<Type>(Context.getRecordType(RD)));
-  QualType T = Context.getDependentNameType(ETK_Typename, NNS, &II);
-
-  CXXScopeSpec SS;
-  SS.MakeTrivial(Context, NNS, SourceRange(NameLoc));
+  if (IsUnqualifiedLookup)
+    S.Diag(NameLoc, diag::ext_found_via_dependent_base_lookup)
+        << &II << S.computeDeclContext(SS, /*EnteringContext=*/true);
+  QualType T =
+      Context.getDependentNameType(ETK_Typename, SS.getScopeRep(), &II);
 
   TypeLocBuilder Builder;
   DependentNameTypeLoc DepTL = Builder.push<DependentNameTypeLoc>(T);
   DepTL.setNameLoc(NameLoc);
   DepTL.setElaboratedKeywordLoc(SourceLocation());
   DepTL.setQualifierLoc(SS.getWithLocInContext(Context));
   return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
 }
 
if (!LookupCtx) {
         //   A qualified-id that refers to a type and in which the
         //   nested-name-specifier depends on a template-parameter (14.6.2)
         //   shall be prefixed by the keyword typename to indicate that the
         //   qualified-id denotes a type, forming an
         //   elaborated-type-specifier (7.1.5.3).
         //
         // We therefore do not perform any name lookup if the result would
         // refer to a member of an unknown specialization.
-        if (!isClassName && !IsCtorOrDtorName)
+        if (!isClassName && !IsCtorOrDtorName) {
+          // For qualified lookup in a class template in MSVC mode, look into
+          // dependent base classes where the primary class template is known.
+          if (getLangOpts().MSVCCompat) {
+            if (ParsedType TypeInBase = recoverFromTypeInKnownDependentBase(
+                    *this, *SS, II, NameLoc))
+              return TypeInBase;
+          }
           return ParsedType();
+        }
         
         // We know from the grammar that this name refers to a type,
         // so build a dependent node to describe the type.
         if (WantNontrivialTypeSourceInfo)
           return ActOnTypenameType(S, SourceLocation(), *SS, II, NameLoc).get();
         
         NestedNameSpecifierLoc QualifierLoc = SS->getWithLocInContext(Context);
         QualType T = CheckTypenameType(ETK_None, SourceLocation(), QualifierLoc,
if (ObjectTypePtr && Result.empty()) {
       //   looked up in the scope of class C. At least one of the lookups shall
       //   find a name that refers to (possibly cv-qualified) T.
       LookupName(Result, S);
     }
   } else {
     // Perform unqualified name lookup.
     LookupName(Result, S);
 
-    // For unqualified lookup in a class template in MSVC mode, look into
-    // dependent base classes where the primary class template is known.
-    if (Result.empty() && getLangOpts().MSVCCompat && (!SS || SS->isEmpty())) {
-      if (ParsedType TypeInBase =
-              recoverFromTypeInKnownDependentBase(*this, II, NameLoc))
-        return TypeInBase;
-    }
-  }
+  }
+
+  CXXScopeSpec NewSS;
+  if (SS && SS->isValid())
+    NewSS = *SS;
+  if (Result.empty() && getLangOpts().MSVCCompat) {
+            recoverFromTypeInKnownDependentBase(*this, NewSS, II, NameLoc))
 
   NamedDecl *IIDecl = nullptr;
   switch (Result.getResultKind()) {
   case LookupResult::NotFound:
   case LookupResult::NotFoundInCurrentInstantiation:
     if (CorrectedII) {
       TypoCorrection Correction = CorrectTypo(
           Result.getLookupNameInfo(), Kind, S, SS,
Sema::ClassifyName(Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name,
   if (NextToken.is(tok::coloncolon)) {
     BuildCXXNestedNameSpecifier(S, *Name, NameLoc, NextToken.getLocation(),
                                 QualType(), false, SS, nullptr, false);
   }
 
   LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName);
   LookupParsedName(Result, S, &SS, !CurMethod);
 
   // For unqualified lookup in a class template in MSVC mode, look into
   // dependent base classes where the primary class template is known.
-  if (Result.empty() && SS.isEmpty() && getLangOpts().MSVCCompat) {
+  CXXScopeSpec NewSS = SS;
+  if (Result.empty() && getLangOpts().MSVCCompat) {
     if (ParsedType TypeInBase =
-            recoverFromTypeInKnownDependentBase(*this, *Name, NameLoc))
+            recoverFromTypeInKnownDependentBase(*this, NewSS, *Name, NameLoc))
       return TypeInBase;
   }
 
   // Perform lookup for Objective-C instance variables (including automatically 
   // synthesized instance variables), if we're in an Objective-C method.
   // FIXME: This lookup really, really needs to be folded in to the normal
   // unqualified lookup mechanism.
   if (!SS.isSet() && CurMethod && !isResultTypeOrTemplate(Result, NextToken)) {

lib/Sema/SemaExpr.cpp

if (!SS.isEmpty()) {
     return true;
   }
 
   // Give up, we can't recover.
   Diag(R.getNameLoc(), diagnostic) << Name;
   return true;
 }
 
-/// In Microsoft mode, if we are inside a template class whose parent class has
-/// dependent base classes, and we can't resolve an unqualified identifier, then
-/// assume the identifier is a member of a dependent base class.  We can only
-/// recover successfully in static methods, instance methods, and other contexts
-/// where 'this' is available.  This doesn't precisely match MSVC's
-/// instantiation model, but it's close enough.
-static Expr *
-recoverFromMSUnqualifiedLookup(Sema &S, ASTContext &Context,
-                               DeclarationNameInfo &NameInfo,
-                               SourceLocation TemplateKWLoc,
-                               const TemplateArgumentListInfo *TemplateArgs) {
-  // Only try to recover from lookup into dependent bases in static methods or
-  // contexts where 'this' is available.
-  QualType ThisType = S.getCurrentThisType();
-  const CXXRecordDecl *RD = nullptr;
+bool Sema::isInClassWithAnyDependentBase(SourceLocation Loc,
+                                         bool IsLastChanceToRecover,
+                                         CXXScopeSpec *SS, QualType ObjectType,
+                                         const IdentifierInfo *II) {
+  CXXRecordDecl *RD = nullptr;
+  if (!ObjectType.isNull()) {
+    // If ObjectType is defined - get cxx scope from this type.
+    RD = dyn_cast_or_null<CXXRecordDecl>(computeDeclContext(ObjectType));
+  } else if (!SS || SS->isEmpty()) {
+    // Only try to recover from lookup into dependent bases in static methods
+    // or contexts where 'this' is available.
+    QualType ThisType = getCurrentThisType();
     if (!ThisType.isNull())
       RD = ThisType->getPointeeType()->getAsCXXRecordDecl();
-  else if (auto *MD = dyn_cast<CXXMethodDecl>(S.CurContext))
+    else if (auto *MD = dyn_cast<CXXMethodDecl>(CurContext))
       RD = MD->getParent();
+  } else {
+    // Cxx scope is set - get class from this scope.
+    RD = dyn_cast_or_null<CXXRecordDecl>(
+        computeDeclContext(*SS, /*EnteringContext=*/true));
+  }
   if (!RD || !RD->hasAnyDependentBases())
-    return nullptr;
-
-  // Diagnose this as unqualified lookup into a dependent base class.  If 'this'
-  // is available, suggest inserting 'this->' as a fixit.
-  SourceLocation Loc = NameInfo.getLoc();
-  auto DB = S.Diag(Loc, diag::ext_undeclared_unqual_id_with_dependent_base);
-  DB << NameInfo.getName() << RD;
-
-  if (!ThisType.isNull()) {
-    DB << FixItHint::CreateInsertion(Loc, "this->");
-    return CXXDependentScopeMemberExpr::Create(
-        Context, /*This=*/nullptr, ThisType, /*IsArrow=*/true,
-        /*Op=*/SourceLocation(), NestedNameSpecifierLoc(), TemplateKWLoc,
-        /*FirstQualifierInScope=*/nullptr, NameInfo, TemplateArgs);
+    return false;
+  // Compute temp cxx scope to check that II member decl exists in this scope.
+  CXXScopeSpec TempSS;
+  if (!SS || SS->isEmpty()) {
+    auto *NNS = NestedNameSpecifier::Create(
+        Context, /*Prefix=*/nullptr, /*Template=*/false, RD->getTypeForDecl());
+    TempSS.MakeTrivial(Context, NNS, SourceRange(Loc, Loc));
+  } else {
+    TempSS = *SS;
+  }
+  if (isMemberInClassWithAnyDependentBase(TempSS, Loc, *II,
+                                          getCurrentThisType().isNull(),
+                                          IsLastChanceToRecover)) {
+    // Found specified member decl in dependent class.
+    if (ObjectType.isNull() && SS && SS->isEmpty()) {
+      *SS = TempSS;
+      if (II)
+        Diag(Loc, diag::ext_found_via_dependent_base_lookup)
+            << II << computeDeclContext(*SS, /*EnteringContext=*/true);
     }
-
-  // Synthesize a fake NNS that points to the derived class.  This will
-  // perform name lookup during template instantiation.
-  CXXScopeSpec SS;
-  auto *NNS =
-      NestedNameSpecifier::Create(Context, nullptr, true, RD->getTypeForDecl());
-  SS.MakeTrivial(Context, NNS, SourceRange(Loc, Loc));
-  return DependentScopeDeclRefExpr::Create(
-      Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo,
-      TemplateArgs);
+    return true;
+  }
+  return false;
 }
 
 ExprResult
 Sema::ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
                         SourceLocation TemplateKWLoc, UnqualifiedId &Id,
                         bool HasTrailingLParen, bool IsAddressOfOperand,
                         std::unique_ptr<CorrectionCandidateCallback> CCC,
                         bool IsInlineAsmIdentifier, Token *KeywordReplacement) {
if (R.empty() && HasTrailingLParen && II && !getLangOpts().CPlusPlus) {
     if (D) R.addDecl(D);
   }
 
   // Determine whether this name might be a candidate for
   // argument-dependent lookup.
   bool ADL = UseArgumentDependentLookup(SS, R, HasTrailingLParen);
 
   if (R.empty() && !ADL) {
-    if (SS.isEmpty() && getLangOpts().MSVCCompat) {
-      if (Expr *E = recoverFromMSUnqualifiedLookup(*this, Context, NameInfo,
-                                                   TemplateKWLoc, TemplateArgs))
-        return E;
+    // In Microsoft mode, if we are inside a template class whose parent class
+    // has dependent base classes, and we can't resolve an unqualified
+    // identifier, then assume the identifier is a member of a dependent base
+    // class. We can only recover successfully in static methods, instance
+    // methods, and other contexts where 'this' is available. This doesn't
+    // precisely match MSVC's instantiation model, but it's close enough.
+    if (SS.isEmpty() && getLangOpts().MSVCCompat &&
+        isInClassWithAnyDependentBase(NameLoc, /*IsLastChanceToRecover=*/true,
+                                      &SS, QualType(), II)) {
+      if (getCurrentThisType().isNull())
+        return DependentScopeDeclRefExpr::Create(
+            Context, SS.getWithLocInContext(Context), TemplateKWLoc, NameInfo,
+            TemplateArgs);
+      return CXXDependentScopeMemberExpr::Create(
+          Context, /*This=*/nullptr, getCurrentThisType(),
+          /*IsArrow=*/true,
+          /*Op=*/SourceLocation(), NestedNameSpecifierLoc(), TemplateKWLoc,
+          /*FirstQualifierInScope=*/nullptr, NameInfo, TemplateArgs);
     }
 
     // Don't diagnose an empty lookup for inline assembly.
     if (IsInlineAsmIdentifier)
       return ExprError();
 
     // If this name wasn't predeclared and if this is not a function
     // call, diagnose the problem.
     TypoExpr *TE = nullptr;

lib/Sema/SemaTemplate.cpp

default:
     return TNK_Non_template;
   }
 
   QualType ObjectType = ObjectTypePtr.get();
 
   LookupResult R(*this, TName, Name.getLocStart(), LookupOrdinaryName);
   LookupTemplateName(R, S, SS, ObjectType, EnteringContext,
                      MemberOfUnknownSpecialization);
-  if (R.empty()) return TNK_Non_template;
+  if (R.empty()) {
+    // In MSVC mode resolve symbol in a class with dependent bases on
+    // instantiation.
+    if (getLangOpts().MSVCCompat && !hasTemplateKeyword &&
+        Name.getKind() == UnqualifiedId::IK_Identifier) {
+      if (S && S->getFnParent() &&
+          isInClassWithAnyDependentBase(Name.getLocStart(),
+                                        /*IsLastChanceToRecover=*/false, &SS,
+                                        ObjectType, Name.Identifier)) {
+        R.suppressDiagnostics();
+        // Mark class template declaration as a TNK_Type_template for proper AST
+        // node generation if it used in expression in constructs like
+        // typecasts/constructor calls:
+        // if (Templ<T>(a))
+        //     ^~~~~
+        //     typename
+        // use of undeclared identifier 'Templ'
+        if (isClassTemplateInClassWithAnyDependentBase(SS, Name.getLocStart(),
+                                                       *Name.Identifier)) {
+          TemplateResult = TemplateTy::make(Context.getDependentTemplateName(
+              SS.getScopeRep(), Name.Identifier));
+          return TNK_Type_template;
+        }
+        MemberOfUnknownSpecialization = true;
+      }
+    }
+    return TNK_Non_template;
+  }
   if (R.isAmbiguous()) {
     // Suppress diagnostics;  we'll redo this lookup later.
     R.suppressDiagnostics();
 
     // FIXME: we might have ambiguous templates, in which case we
     // should at least parse them properly!
     return TNK_Non_template;
   }

test/SemaCXX/MicrosoftCompatibility.cpp

 
 template<class T, class U>
 class C : private A<T>, public B<U> {
 public:
    typedef A<T> Base1;
    typedef B<U> Base2;
    typedef A<U> Base3;
 
-   A<T>::TYPE a1; // expected-warning {{missing 'typename' prior to dependent type name}}
-   Base1::TYPE a2; // expected-warning {{missing 'typename' prior to dependent type name}}
+   A<T>::TYPE a1;
+   Base1::TYPE a2;
 
-   B<U>::TYPE a3; // expected-warning {{missing 'typename' prior to dependent type name}}
-   Base2::TYPE a4; // expected-warning {{missing 'typename' prior to dependent type name}}
+   B<U>::TYPE a3;
+   Base2::TYPE a4;
 
-   A<U>::TYPE a5; // expected-error {{missing 'typename' prior to dependent type name}}
-   Base3::TYPE a6; // expected-error {{missing 'typename' prior to dependent type name}}
+   A<U>::TYPE a5;
+   Base3::TYPE a6;
  };
 
 class D {
 public:
     typedef int Type;
 };
 
 template <class T>

test/SemaTemplate/ms-lookup-template-base-classes.cpp

public:
   int var;
 };
 
 
 template<class T>
 class B : public A<T> {
 public:
   void f() {
-    var = 3; // expected-warning {{use of undeclared identifier 'var'; unqualified lookup into dependent bases of class template 'B' is a Microsoft extension}}
+    var = 3; // expected-warning {{use of identifier 'var' found via unqualified lookup into dependent bases of class template 'B<T>' is a Microsoft extension}}
   }
 };
 
 template class B<int>;
 
 }
 
 

 public:
   int m_hWnd;
 };
 
 template <class T>
 class A : public T {
 public:
   void f(int hWnd) {
-    m_hWnd = 1; // expected-warning {{use of undeclared identifier 'm_hWnd'; unqualified lookup into dependent bases of class template 'A' is a Microsoft extension}}
+    m_hWnd = 1; // expected-warning {{use of identifier 'm_hWnd' found via unqualified lookup into dependent bases of class template 'A<T>' is a Microsoft extension}}
   }
 };
 
 template class A<C>;
 
 }
 
 namespace PR12701 {
template <typename T> struct Derived : Base<T> {
   }
 };
 template struct Derived<int>;
 }
 
 namespace typedef_in_base {
 template <typename T> struct A { typedef T NameFromBase; };
 template <typename T> struct B : A<T> {
-  NameFromBase m; // expected-warning {{found via unqualified lookup into dependent bases}}
+  NameFromBase m; // expected-warning {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases of class template 'B<T>' is a Microsoft extension}}
 };
 static_assert(sizeof(B<int>) == 4, "");
 }
 
 namespace struct_in_base {
 template <typename T> struct A { struct NameFromBase {}; };
 template <typename T> struct B : A<T> {
-  NameFromBase m; // expected-warning {{found via unqualified lookup into dependent bases}}
+  NameFromBase m; // expected-warning {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases of class template 'B<T>' is a Microsoft extension}}
 };
 static_assert(sizeof(B<int>) == 1, "");
 }
 
 namespace enum_in_base {
 template <typename T> struct A { enum NameFromBase { X }; };
 template <typename T> struct B : A<T> {
-  NameFromBase m; // expected-warning {{found via unqualified lookup into dependent bases}}
+  NameFromBase m; // expected-warning {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases of class template 'B<T>' is a Microsoft extension}}
 };
 static_assert(sizeof(B<int>) == sizeof(A<int>::NameFromBase), "");
 }
 
 namespace two_types_in_base {
 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 {{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}}
+  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 template 'C<T>' is a Microsoft extension}}
 };
 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 {
 template <typename T> struct A { typedef T NameFromBase; };
 template <typename T> struct B { static const T NameFromBase = 42; };
 template <typename T> struct C : A<T>, B<T> {
   NameFromBase m; // expected-error {{unknown type name 'NameFromBase'}}
 };
 }
 
 namespace classify_type_from_base {
 template <typename T> struct A { struct NameFromBase {}; };
 template <typename T> struct B : A<T> {
-  A<NameFromBase> m; // expected-warning {{found via unqualified lookup into dependent bases}}
+  A<NameFromBase> m; // expected-warning {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases of class template 'B<T>' is a Microsoft extension}}
 };
 }
 
 namespace classify_nontype_from_base {
 // MSVC does not do lookup of non-type declarations from dependent template base
 // classes.  The extra lookup only applies to types.
 template <typename T> struct A { void NameFromBase() {} };
 template <void (*F)()> struct B { };

 struct C : A<int> { NameFromBase m; }; // expected-error {{unknown type name 'NameFromBase'}}
 }
 
 namespace type_in_base_of_dependent_base {
 struct A { typedef int NameFromBase; };
 template <typename T>
 struct B : A {};
 template <typename T>
-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}}
+struct C : B<T> { NameFromBase m; }; // expected-warning {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases of class template 'C<T>' is a Microsoft extension}}
 }
 
 namespace type_in_second_dependent_base {
 template <typename T>
 struct A {};
 template<typename T>
 struct B { typedef T NameFromBase; };
 template <typename T>
-struct D : A<T>, B<T> { NameFromBase m; }; // expected-warning {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
+struct D : A<T>, B<T> { NameFromBase m; }; // expected-warning {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases of class template 'D<T>' is a Microsoft extension}}
 }
 
 namespace type_in_second_non_dependent_base {
 struct A {};
 struct B { typedef int NameFromBase; };
 template<typename T>
 struct C : A, B {};
 template <typename T>
-struct D : C<T> { NameFromBase m; }; // expected-warning {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
+struct D : C<T> { NameFromBase m; }; // expected-warning {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases of class template 'D<T>' 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}}
+struct C : B<T>, virtual A<T> { NameFromBase m; }; // expected-warning {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases of class template 'C<T>' 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:}}
+struct C : B<T>, public A<T> { NameFromBase m; }; // expected-warning {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases of class template 'C<T>' 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 type_in_dependent_base_of_non_dependent_type {
 template<typename T> struct A { typedef int NameFromBase; };
 template<typename T> struct B : A<T> {
   struct C;
   template<typename TT>
   struct D : C {
-    NameFromBase m; // expected-warning {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
+    NameFromBase m; // expected-warning {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases of class template 'B<T>' is a Microsoft extension}}
   };
   struct E : C {
-    NameFromBase m; // expected-warning {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
+    NameFromBase m; // expected-warning {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases of class template 'B<T>' is a Microsoft extension}}
   };
 };
 template<typename T> struct B<T>::C : B {
-  NameFromBase m; // expected-warning {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
+  NameFromBase m; // expected-warning {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases of class template 'B<T>' is a Microsoft extension}}
 };
 template<typename T> struct F : B<T>::C {
   NameFromBase m; // expected-error {{unknown type name 'NameFromBase'}}
 };
 }
 
 namespace lookup_in_function_contexts {
 template <typename T> struct A { typedef T NameFromBase; };

 template <int N> int f() { return N; }
 template <typename T> int f() { return sizeof(T); }
 
 // Dependent base class with type.
 template <typename T>
 struct A { typedef T NameFromBase; };
 template <typename T>
 struct B : A<T> {
-  // expected-warning@+1 {{found via unqualified lookup into dependent bases}}
+  // expected-warning@+1 {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases of class template 'B<T>' is a Microsoft extension}}
   int x = f<NameFromBase>();
 };
 
 // Dependent base class with enum.
 template <typename T> struct C { enum { NameFromBase = 4 }; };
 template <typename T> struct D : C<T> {
-  // expected-warning@+1 {{use of undeclared identifier 'NameFromBase'; unqualified lookup into dependent bases}}
+  // expected-warning@+1 {{use of identifier 'NameFromBase' found via unqualified lookup into dependent bases}}
   int x = f<NameFromBase>();
 };
 }
 
 namespace function_template_undef_impl {
 template<class T>
 void f() {
   Undef::staticMethod(); // expected-error {{use of undeclared identifier 'Undef'}}

 using D = C<T>;
 
 template <typename T>
 struct E : D<T>
 {
   XXX x; // expected-error {{unknown type name}}
 };
 }
+
+namespace complex_qualified_and_unqualified_lookup {
+template <class T> struct Base {
+  T a;
+  // expected-note@+2 4 {{template is declared here}}
+  // expected-note@+1 2 {{must qualify identifier to find this declaration in dependent base class}}
+  template <class U> struct InnerBase {};
+  typedef InnerBase<T> TDInnerBase;
+  // expected-note@+1 {{must qualify identifier to find this declaration in dependent base class}}
+  template <class G> void f(G t) {}
+  // expected-note@+1 {{must qualify identifier to find this declaration in dependent base class}}
+  template <class G> static void fs(G t) {}
+};
+
+template <class T> struct Sub : Base<T> {
+  // expected-note@+2 4 {{template is declared here}}
+  // expected-note@+1 2 {{must qualify identifier to find this declaration in dependent base class}}
+  template <class U> struct InnerSub {};
+  typedef InnerSub<T> TDInnerSub;
+  void g() {}
+};
+
+template <class T> struct SubSub : Sub<T> {
+  // expected-warning@+1 {{use of identifier 'TDInnerBase' found via unqualified lookup into dependent bases of class template 'SubSub<T>' is a Microsoft extension}}
+  TDInnerBase b;
+  void g() {
+    typedef Base<T> BaseTD;
+    BaseTD::TDInnerBase();
+    typename Sub<T>::template InnerBase<T>();
+    // expected-warning@+1 {{use of identifier 'a' found via unqualified lookup into dependent bases of class template 'SubSub<T>' is a Microsoft extension}}
+    a = T();
+    // expected-warning@+1 {{use of identifier 'TDInnerBase' found via unqualified lookup into dependent bases of class template 'SubSub<T>' is a Microsoft extension}}
+    b = TDInnerBase();
+    // expected-warning@+1 {{use of identifier 'f' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
+    f(4);
+    // expected-warning@+2 {{use of identifier 'f' found via unqualified lookup into dependent bases of class template 'SubSub<T>' is a Microsoft extension}}
+    // expected-warning@+1 {{use 'template' keyword to treat 'f' as a dependent template name}}
+    f<int>(4);
+    // expected-warning@+2 {{use of identifier 'f' found via unqualified lookup into dependent bases of class template 'SubSub<T>' is a Microsoft extension}}
+    // expected-warning@+1 {{use 'template' keyword to treat 'f' as a dependent template name}}
+    f<T>(4);
+    this->f(4);
+    // expected-warning@+1 {{use 'template' keyword to treat 'f' as a dependent template name}}
+    this->f<int>(4);
+    // expected-warning@+1 {{use 'template' keyword to treat 'f' as a dependent template name}}
+    this->f<T>(4);
+    Sub<T>::template f<int>(4);
+    this->template f<int>(4);
+    Sub<T>::template f<T>(4);
+    this->template f<T>(4);
+    // expected-warning@+1 {{use of identifier 'InnerBase' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
+    InnerBase(); // expected-error {{cannot refer to class template 'InnerBase' without a template argument list}}
+    // expected-warning@+1 {{use of identifier 'InnerBase' found via unqualified lookup into dependent bases of class template 'SubSub<T>' is a Microsoft extension}}
+    InnerBase<T>();
+    // expected-warning@+1 {{use of identifier 'TDInnerBase' found via unqualified lookup into dependent bases of class template 'SubSub<T>' is a Microsoft extension}}
+    TDInnerBase();
+    // expected-warning@+1 {{use of identifier 'InnerSub' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
+    InnerSub(); // expected-error {{cannot refer to class template 'InnerSub' without a template argument list}}
+    // expected-warning@+1 {{use of identifier 'InnerSub' found via unqualified lookup into dependent bases of class template 'SubSub<T>' is a Microsoft extension}}
+    InnerSub<T>();
+    // expected-warning@+1 {{use of identifier 'TDInnerSub' found via unqualified lookup into dependent bases of class template 'SubSub<T>' is a Microsoft extension}}
+    TDInnerSub();
+    Sub<T>::InnerBase<T>();
+    Sub<T>::InnerBase(); // expected-error {{cannot refer to class template 'InnerBase' without a template argument list}}
+    Sub<T>::TDInnerBase();
+    Sub<T>::InnerSub<T>();
+    Sub<T>::InnerSub(); // expected-error {{cannot refer to class template 'InnerSub' without a template argument list}}
+    Sub<T>::TDInnerSub();
+  }
+  static void gs() {
+    typedef Base<T> BaseTD;
+    BaseTD::TDInnerBase();
+    // expected-warning@+1 {{use of identifier 'fs' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
+    fs(4);
+    // expected-warning@+2 {{use of identifier 'fs' found via unqualified lookup into dependent bases of class template 'SubSub<T>' is a Microsoft extension}}
+    // expected-warning@+1 {{use 'template' keyword to treat 'fs' as a dependent template name}}
+    fs<int>(4);
+    // expected-warning@+2 {{use of identifier 'fs' found via unqualified lookup into dependent bases of class template 'SubSub<T>' is a Microsoft extension}}
+    // expected-warning@+1 {{use 'template' keyword to treat 'fs' as a dependent template name}}
+    fs<T>(4);
+    // expected-warning@+1 {{use of identifier 'InnerBase' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
+    InnerBase(); // expected-error {{cannot refer to class template 'InnerBase' without a template argument list}}
+    // expected-warning@+1 {{use of identifier 'InnerBase' found via unqualified lookup into dependent bases of class template 'SubSub<T>' is a Microsoft extension}}
+    InnerBase<T>();
+    // expected-warning@+1 {{use of identifier 'TDInnerBase' found via unqualified lookup into dependent bases of class template 'SubSub<T>' is a Microsoft extension}}
+    TDInnerBase();
+    // expected-warning@+1 {{use of identifier 'InnerSub' found via unqualified lookup into dependent bases of class template 'SubSub<T>' is a Microsoft extension}}
+    InnerSub<T>();
+     // expected-warning@+1 {{use of identifier 'InnerSub' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
+   InnerSub(); // expected-error {{cannot refer to class template 'InnerSub' without a template argument list}}
+    // expected-warning@+1 {{use of identifier 'TDInnerSub' found via unqualified lookup into dependent bases of class template 'SubSub<T>' is a Microsoft extension}}
+    TDInnerSub();
+    Sub<T>::fs(4);
+    // expected-warning@+1 {{use 'template' keyword to treat 'fs' as a dependent template name}}
+    Sub<T>::fs<int>(4);
+    // expected-warning@+1 {{use 'template' keyword to treat 'fs' as a dependent template name}}
+    Sub<T>::fs<T>(4);
+    Sub<T>::InnerBase<T>();
+    Sub<T>::InnerBase(); // expected-error {{cannot refer to class template 'InnerBase' without a template argument list}}
+    Sub<T>::TDInnerBase();
+    Sub<T>::InnerSub<T>();
+    Sub<T>::InnerSub(); // expected-error {{cannot refer to class template 'InnerSub' without a template argument list}}
+    Sub<T>::TDInnerSub();
+  }
+};
+
+void foo() {
+  Sub<int> i;
+  SubSub<int> ii;
+  i.g();
+  // expected-note@+1 {{in instantiation of member function 'complex_qualified_and_unqualified_lookup::SubSub<int>::g' requested here}}
+  ii.g();
+  // expected-note@+1 {{in instantiation of member function 'complex_qualified_and_unqualified_lookup::SubSub<int>::gs' requested here}}
+  SubSub<int>::gs();
+}
+}

test/SemaTemplate/typename-specifier.cpp

 Foo<Base> x;
 } // namespace missing_typename_and_base
 
 namespace func_type_vs_construct_tmp {
 template <typename> struct S { typedef int type; };
 template <typename T> void f();
 template <int N> void f();
 
-// expected-error@+1 {{missing 'typename' prior to dependent type name 'S<int>::type'}}
+#ifndef MSVC
+// expected-error@+2 {{missing 'typename' prior to dependent type name 'S<int>::type'}}
+#endif
 template <typename T> void g() { f</*typename*/ S<T>::type(int())>(); }
 
 // Adding typename does fix the diagnostic.
 template <typename T> void h() { f<typename S<T>::type(int())>(); }
 
 void j() {
-  g<int>(); // expected-note-re {{in instantiation {{.*}} requested here}}
+#ifndef MSVC
+  // expected-note-re@+2 {{in instantiation {{.*}} requested here}}
+#endif
+  g<int>();
   h<int>();
 }
 } // namespace func_type_vs_construct_tmp
 
 namespace pointer_vs_multiply {
 int x;
 // expected-error@+1 {{missing 'typename' prior to dependent type name 'B::type_or_int'}}
 template <typename T> void g() { T::type_or_int * x; }