[MSVC] Improved late parsing of template functions.

[ABataev]

Summary

MSVC actively uses unqualified lookup in dependent bases, lookup at the instantiation point (non-dependent names may be resolved on things declared later) etc. and all this stuff is the main cause of incompatibility between clang and MSVC.
Clang tries to emulate MSVC behavior but it may fail in many cases. Patch tries to improve compatibility between clang and MSVC. Each time a new instantiation of the function is required, a new copy of the original templated function is created and the body of original function is parsed in the context of this new copy. If unqualified lookup is detected, patch tries to find the required name in the instantiated context. Also, if the original template function is instantiated, but not used, its body is not parsed and not instantiated (it emulates MSVC behavior).
Patch significantly improves compatibility with ATL/WTL headers, but does not solve troubles with unqualified lookup in dependent bases in default initializers of members, types of member functions/data members and default values of function arguments. This must be fixed later.

[ABataev]

Ping

[ABataev]

Ping

[majnemer]

lib/Sema/SemaLookup.cpp

1044–1070

This looks a lot like forallBases, any chance it could be reused?

[ABataev]

lib/Sema/SemaLookup.cpp

1044–1070

Yes, they are very similar, but forallBases() is a bit different. It checks that the provided callback returns true for all bases. In this case I need a single match, while other bases may not match. That's why I can't reuse forallBases().

[ABataev]

Ping!

[ABataev]

Ping

[rnk]

If I understand correctly, this patch takes template function patterns, copies them into instantiated context, parses them in that context, and then instantiates them in that context. The key difference is that today's fdelayed-template-parsing doesn't parse the body of the function in the instantiation context. It just allows access to names at global scope that were encountered after the template pattern.

So, if I run -ast-dump, do I end up seeing both the pattern and the fully instantiated function with this patch?

This patch removes a lot of warnings from our tests. We lose a lot of our ability to diagnose MSVC-isms with this approach. I wonder if there's a better way to do delayed template parsing the way we were before, but make the template arguments available during lookup.

[ABataev]

In D22955#598081, @rnk wrote:

If I understand correctly, this patch takes template function patterns, copies them into instantiated context, parses them in that context, and then instantiates them in that context. The key difference is that today's fdelayed-template-parsing doesn't parse the body of the function in the instantiation context. It just allows access to names at global scope that were encountered after the template pattern.

So, if I run -ast-dump, do I end up seeing both the pattern and the fully instantiated function with this patch?

This patch removes a lot of warnings from our tests. We lose a lot of our ability to diagnose MSVC-isms with this approach. I wonder if there's a better way to do delayed template parsing the way we were before, but make the template arguments available during lookup.

In D22955#598081, @rnk wrote:

If I understand correctly, this patch takes template function patterns, copies them into instantiated context, parses them in that context, and then instantiates them in that context. The key difference is that today's fdelayed-template-parsing doesn't parse the body of the function in the instantiation context. It just allows access to names at global scope that were encountered after the template pattern.

Yes, you're right.

So, if I run -ast-dump, do I end up seeing both the pattern and the fully instantiated function with this patch?

No, you will see only instantiated function.

This patch removes a lot of warnings from our tests. We lose a lot of our ability to diagnose MSVC-isms with this approach. I wonder if there's a better way to do delayed template parsing the way we were before, but make the template arguments available during lookup.

Yes, this is the price we should pay for better MSVC compatibility. I tried several different solutions before ended up with this one and have to say this one is the best I was able to find.

[ABataev]

Ping

include/clang/Sema/Sema.h

public:
   void SetLateTemplateParser(LateTemplateParserCB *LTP,
                              LateTemplateParserCleanupCB *LTPCleanup,
                              void *P) {
     LateTemplateParser = LTP;
     LateTemplateParserCleanup = LTPCleanup;
     OpaqueParser = P;
   }
 
+  FunctionDecl *MSVCInstantiation = nullptr;
+
   class DelayedDiagnostics;
 
   class DelayedDiagnosticsState {
     sema::DelayedDiagnosticPool *SavedPool;
     friend class Sema::DelayedDiagnostics;
   };
   typedef DelayedDiagnosticsState ParsingDeclState;
   typedef DelayedDiagnosticsState ProcessingContextState;
DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R,
                       std::unique_ptr<CorrectionCandidateCallback> CCC,
                       TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr,
                       ArrayRef<Expr *> Args = None, TypoExpr **Out = nullptr);
 
   ExprResult LookupInObjCMethod(LookupResult &LookUp, Scope *S,
                                 IdentifierInfo *II,
                                 bool AllowBuiltinCreation=false);
 
+  void MSVCMakeFakeCXXScopeSpec(LookupResult &R, CXXScopeSpec &SS) const;
   ExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS,
                                         SourceLocation TemplateKWLoc,
                                         const DeclarationNameInfo &NameInfo,
                                         bool isAddressOfOperand,
                                 const TemplateArgumentListInfo *TemplateArgs);
 
   ExprResult BuildDeclRefExpr(ValueDecl *D, QualType Ty,
                               ExprValueKind VK,

 MakeDeductionFailureInfo(ASTContext &Context, Sema::TemplateDeductionResult TDK,
                          sema::TemplateDeductionInfo &Info);
 
 /// \brief Contains a late templated function.
 /// Will be parsed at the end of the translation unit, used by Sema & Parser.
 struct LateParsedTemplate {
   CachedTokens Toks;
   /// \brief The template function declaration to be late parsed.
-  Decl *D;
+  Decl *D = nullptr;
 };
 
 } // end namespace clang
 
 #endif

lib/AST/DeclBase.cpp

bool DeclContext::isDependentContext() const {
   if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(this)) {
     if (Function->getDescribedFunctionTemplate())
       return true;
 
     // Friend function declarations are dependent if their *lexical*
     // context is dependent.
     if (cast<Decl>(this)->getFriendObjectKind())
       return getLexicalParent()->isDependentContext();
+
+    const LangOptions &LO = getParentASTContext().getLangOpts();
+    if (LO.DelayedTemplateParsing && LO.MSVCCompat &&
+        Function->isLateTemplateParsed())
+      return true;
   }
 
   // FIXME: A variable template is a dependent context, but is not a
   // DeclContext. A context within it (such as a lambda-expression)
   // should be considered dependent.
 
   return getParent() && getParent()->isDependentContext();
 }
if ((D->getIdentifierNamespace() == 0 && !isa<UsingDirectiveDecl>(D)) ||
     return true;
 
   // Skip template specializations.
   // FIXME: This feels like a hack. Should DeclarationName support
   // template-ids, or is there a better way to keep specializations
   // from being visible?
   if (isa<ClassTemplateSpecializationDecl>(D))
     return true;
-  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
+  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
     if (FD->isFunctionTemplateSpecialization())
       return true;
+    const LangOptions &LO = FD->getASTContext().getLangOpts();
+    if (LO.DelayedTemplateParsing && LO.MSVCCompat &&
+        FD->isLateTemplateParsed() && FD->isImplicit())
+      return true;
+  }
 
   return false;
 }
 
 /// buildLookup - Build the lookup data structure with all of the
 /// declarations in this DeclContext (and any other contexts linked
 /// to it or transparent contexts nested within it) and return it.
 ///

lib/Parse/ParseTemplate.cpp

if (Tok.is(tok::kw_try)) {
     if (Tok.is(tok::l_brace)) {
       assert((!isa<FunctionTemplateDecl>(LPT.D) ||
               cast<FunctionTemplateDecl>(LPT.D)
                       ->getTemplateParameters()
                       ->getDepth() == TemplateParameterDepth - 1) &&
              "TemplateParameterDepth should be greater than the depth of "
              "current template being instantiated!");
       ParseFunctionStatementBody(LPT.D, FnScope);
+      if (!getLangOpts().MSVCCompat)
         Actions.UnmarkAsLateParsedTemplate(FunD);
     } else
       Actions.ActOnFinishFunctionBody(LPT.D, nullptr);
   }
 
   // Exit scopes.
   FnScope.Exit();
   SmallVectorImpl<ParseScope *>::reverse_iterator I =
    TemplateParamScopeStack.rbegin();

lib/Sema/SemaDecl.cpp

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);
 
+    // Use workaround only in non-instantiation mode.
     // 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 (Result.empty() && getLangOpts().MSVCCompat && (!SS || SS->isEmpty()) &&
+        !MSVCInstantiation) {
       if (ParsedType TypeInBase =
               recoverFromTypeInKnownDependentBase(*this, II, NameLoc))
         return TypeInBase;
     }
   }
 
   NamedDecl *IIDecl = nullptr;
   switch (Result.getResultKind()) {
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);
 
+  // Use workaround only in non-instantiation mode
   // 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) {
+  if (Result.empty() && SS.isEmpty() && getLangOpts().MSVCCompat &&
+      !MSVCInstantiation) {
     if (ParsedType TypeInBase =
             recoverFromTypeInKnownDependentBase(*this, *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
case LookupResult::NotFoundInCurrentInstantiation: {
     //   dependent on a template-parameter is assumed not to name a type
     //   unless the applicable name lookup finds a type name or the name is
     //   qualified by the keyword typename.
     //
     // FIXME: If the next token is '<', we might want to ask the parser to
     // perform some heroics to see if we actually have a
     // template-argument-list, which would indicate a missing 'template'
     // keyword here.
+    if (SS.isEmpty() && getLangOpts().MSVCCompat && MSVCInstantiation)
+      MSVCMakeFakeCXXScopeSpec(Result, SS);
     return ActOnDependentIdExpression(SS, /*TemplateKWLoc=*/SourceLocation(),
                                       NameInfo, IsAddressOfOperand,
                                       /*TemplateArgs=*/nullptr);
   }
 
   case LookupResult::Found:
   case LookupResult::FoundOverloaded:
   case LookupResult::FoundUnresolvedValue:

lib/Sema/SemaExpr.cpp

if (isa<CXXRecordDecl>(DC)) {
         // function parameter list, hence add an explicit check.
         bool isDefaultArgument = !ActiveTemplateInstantiations.empty() &&
                               ActiveTemplateInstantiations.back().Kind ==
             ActiveTemplateInstantiation::DefaultFunctionArgumentInstantiation;
         CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext);
         bool isInstance = CurMethod &&
                           CurMethod->isInstance() &&
                           DC == CurMethod->getParent() && !isDefaultArgument;
-
         // Give a code modification hint to insert 'this->'.
         // TODO: fixit for inserting 'Base<T>::' in the other cases.
         // Actually quite difficult!
-        if (getLangOpts().MSVCCompat)
+        if (getLangOpts().MSVCCompat && !MSVCInstantiation)
           diagnostic = diag::ext_found_via_dependent_bases_lookup;
         if (isInstance) {
           Diag(R.getNameLoc(), diagnostic) << Name
             << FixItHint::CreateInsertion(R.getNameLoc(), "this->");
           CheckCXXThisCapture(R.getNameLoc());
         } else {
           Diag(R.getNameLoc(), diagnostic) << Name;
         }
recoverFromMSUnqualifiedLookup(Sema &S, ASTContext &Context,
   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);
 }
 
+void Sema::MSVCMakeFakeCXXScopeSpec(LookupResult &R, CXXScopeSpec &SS) const {
+  assert(SS.isEmpty() && getLangOpts().MSVCCompat && MSVCInstantiation);
+  if (R.getNamingClass() &&
+      R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation) {
+    // Synthesize a fake NNS that points to the derived class.  This will
+    // perform name lookup during template instantiation.
+    auto *NNS = NestedNameSpecifier::Create(
+        getASTContext(), nullptr, true, R.getNamingClass()->getTypeForDecl());
+    SourceLocation Loc = R.getNameLoc();
+    SS.MakeTrivial(getASTContext(), NNS, SourceRange(Loc, Loc));
+  }
+}
+
 ExprResult
 Sema::ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
                         SourceLocation TemplateKWLoc, UnqualifiedId &Id,
                         bool HasTrailingLParen, bool IsAddressOfOperand,
                         std::unique_ptr<CorrectionCandidateCallback> CCC,
                         bool IsInlineAsmIdentifier, Token *KeywordReplacement) {
   assert(!(IsAddressOfOperand && HasTrailingLParen) &&
          "cannot be direct & operand and have a trailing lparen");
if (TemplateArgs) {
     // Lookup the template name again to correctly establish the context in
     // which it was found. This is really unfortunate as we already did the
     // lookup to determine that it was a template name in the first place. If
     // this becomes a performance hit, we can work harder to preserve those
     // results until we get here but it's likely not worth it.
     bool MemberOfUnknownSpecialization;
     LookupTemplateName(R, S, SS, QualType(), /*EnteringContext=*/false,
                        MemberOfUnknownSpecialization);
-    
     if (MemberOfUnknownSpecialization ||
-        (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation))
+        (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation)) {
+      if (SS.isEmpty() && getLangOpts().MSVCCompat && MSVCInstantiation)
+        MSVCMakeFakeCXXScopeSpec(R, SS);
       return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo,
                                         IsAddressOfOperand, TemplateArgs);
+    }
   } else {
     bool IvarLookupFollowUp = II && !SS.isSet() && getCurMethodDecl();
     LookupParsedName(R, S, &SS, !IvarLookupFollowUp);
 
     // If the result might be in a dependent base class, this is a dependent 
     // id-expression.
-    if (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation)
+    if (R.getResultKind() == LookupResult::NotFoundInCurrentInstantiation) {
+      if (SS.isEmpty() && getLangOpts().MSVCCompat && MSVCInstantiation)
+        MSVCMakeFakeCXXScopeSpec(R, SS);
       return ActOnDependentIdExpression(SS, TemplateKWLoc, NameInfo,
                                         IsAddressOfOperand, TemplateArgs);
+    }
 
     // If this reference is in an Objective-C method, then we need to do
     // some special Objective-C lookup, too.
     if (IvarLookupFollowUp) {
       ExprResult E(LookupInObjCMethod(R, S, II, true));
       if (E.isInvalid())
         return ExprError();
 
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 (SS.isEmpty() && getLangOpts().MSVCCompat && !MSVCInstantiation) {
       if (Expr *E = recoverFromMSUnqualifiedLookup(*this, Context, NameInfo,
                                                    TemplateKWLoc, TemplateArgs))
         return E;
     }
 
     // Don't diagnose an empty lookup for inline assembly.
     if (IsInlineAsmIdentifier)
       return ExprError();

lib/Sema/SemaLookup.cpp

struct FindLocalExternScope {
   ~FindLocalExternScope() {
     restore();
   }
   LookupResult &R;
   bool OldFindLocalExtern;
 };
 } // end anonymous namespace
 
+static DeclContext *GetMSVCInstantiationContext(Sema &S, DeclContext *Ctx) {
+  assert(S.getLangOpts().MSVCCompat && S.MSVCInstantiation);
+  if (auto *RD = dyn_cast<CXXRecordDecl>(Ctx)) {
+    for (DeclContext *C = S.MSVCInstantiation; C && !C->isTranslationUnit();
+         C = C->getLookupParent()) {
+      if (auto *InstRD = dyn_cast<CXXRecordDecl>(C))
+        if (isTemplateInstantiation(InstRD->getTemplateSpecializationKind()) &&
+            RD->Equals(InstRD->getTemplateInstantiationPattern()))
+          return C;
+    }
+  }
+  return nullptr;
+}
+
+static bool isBaseClass(const CXXRecordDecl *Record, CXXRecordDecl *Base) {
+  SmallVector<const CXXRecordDecl *, 8> Queue;
+
+  while (true) {
+    for (const auto &I : Record->bases()) {
+      const RecordType *Ty = I.getType()->getAs<RecordType>();
+      if (!Ty)
+        continue;
+
+      CXXRecordDecl *RecBase =
+          cast_or_null<CXXRecordDecl>(Ty->getDecl()->getDefinition());
+      if (!RecBase || (RecBase->isDependentContext() &&
+                       !RecBase->isCurrentInstantiation(Record)))
+        continue;
+
+      Queue.push_back(RecBase);
+      if (RecBase->getCanonicalDecl() == Base)
+        return true;
+    }
+
+    if (Queue.empty())
+      break;
+    Record = Queue.pop_back_val(); // not actually a queue.
+  }
+
+  return false;
+}
+
 bool Sema::CppLookupName(LookupResult &R, Scope *S) {
   assert(getLangOpts().CPlusPlus && "Can perform only C++ lookup");
 
   DeclarationName Name = R.getLookupName();
   Sema::LookupNameKind NameKind = R.getLookupKind();
 
   // If this is the name of an implicitly-declared special member function,
   // go through the scope stack to implicitly declare
if (Ctx) {
         // Perform qualified name lookup into this context.
         // FIXME: In some cases, we know that every name that could be found by
         // this qualified name lookup will also be on the identifier chain. For
         // example, inside a class without any base classes, we never need to
         // perform qualified lookup because all of the members are on top of the
         // identifier chain.
         if (LookupQualifiedName(R, Ctx, /*InUnqualifiedLookup=*/true))
           return true;
+        if (!R.wasNotFoundInCurrentInstantiation() &&
+            getLangOpts().MSVCCompat && MSVCInstantiation) {
+          if (DeclContext *InstCtx = GetMSVCInstantiationContext(*this, Ctx)) {
+            if (LookupQualifiedName(R, InstCtx,
+                                    /*InUnqualifiedLookup=*/true)) {
+              auto *ND = cast<NamedDecl>((*R.begin())->getCanonicalDecl());
+              if (auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
+                if (const auto *Ty = RD->getTypeForDecl()->castAs<RecordType>())
+                  if (Decl *D = Ty->getDecl()->getCanonicalDecl())
+                    ND = cast<NamedDecl>(D);
+              }
+              if (ND->isCXXClassMember()) {
+                auto *Parent = cast<CXXRecordDecl>(ND->getDeclContext())
+                                   ->getCanonicalDecl();
+                auto *DepParent = cast<CXXRecordDecl>(Ctx);
+                bool EnableDiag =
+                    isTemplateInstantiation(
+                        Parent->getTemplateSpecializationKind()) ||
+                    !isBaseClass(DepParent, Parent);
+                if (auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
+                  auto *InstParent = cast<CXXRecordDecl>(InstCtx);
+                  EnableDiag =
+                      (isTemplateInstantiation(
+                           RD->getTemplateSpecializationKind()) &&
+                       InstParent->isProvablyNotDerivedFrom(RD)) ||
+                      (!isTemplateInstantiation(
+                           RD->getTemplateSpecializationKind()) &&
+                       !isBaseClass(DepParent, RD) &&
+                       !(Parent->Encloses(InstCtx) || Parent == InstCtx));
+                }
+                if (EnableDiag) {
+                  auto DB = Diag(R.getNameLoc(),
+                                 diag::ext_found_via_dependent_bases_lookup)
+                            << R.getLookupName();
+                  if (ND->isCXXInstanceMember() && !isa<TypeDecl>(ND))
+                    DB << FixItHint::CreateInsertion(R.getNameLoc(), "this->");
+                }
+                if (!isa<TypeDecl>(ND)) {
+                  R.clear();
+                  R.setNotFoundInCurrentInstantiation();
+                  R.setNamingClass(cast<CXXRecordDecl>(Ctx));
+                }
+              }
+              return true;
+            }
+          }
+        }
       }
     }
   }
 
   // Stop if we ran out of scopes.
   // FIXME:  This really, really shouldn't be happening.
   if (!S) return false;
 

lib/Sema/SemaTemplate.cpp

Diag(IILoc, diag::err_template_kw_missing)
     << Qualifier << II.getName()
     << FixItHint::CreateInsertion(IILoc, "template ");
   SuggestedTemplate
     = TemplateTy::make(Context.getDependentTemplateName(Qualifier, &II));
   SuggestedKind = TNK_Dependent_template_name;
   return true;
 }
 
+namespace {
+/// Do not perform lookup in instantiations during qualified lookup.
+class MSVCDoNotLookupInInstance {
+  Sema &S;
+  FunctionDecl *MSVCInstantiation = nullptr;
+
+public:
+  MSVCDoNotLookupInInstance(Sema &S)
+      : S(S), MSVCInstantiation(S.MSVCInstantiation) {
+    S.MSVCInstantiation = nullptr;
+  }
+  ~MSVCDoNotLookupInInstance() { S.MSVCInstantiation = MSVCInstantiation; }
+};
+} // namespace
+
 void Sema::LookupTemplateName(LookupResult &Found,
                               Scope *S, CXXScopeSpec &SS,
                               QualType ObjectType,
                               bool EnteringContext,
                               bool &MemberOfUnknownSpecialization) {
   // Determine where to perform name lookup
   MemberOfUnknownSpecialization = false;
   DeclContext *LookupCtx = nullptr;
if (!ObjectType.isNull() && Found.empty()) {
       //   In a class member access expression (5.2.5), if the . or -> token is
       //   immediately followed by an identifier followed by a <, the
       //   identifier must be looked up to determine whether the < is the
       //   beginning of a template argument list (14.2) or a less-than operator.
       //   The identifier is first looked up in the class of the object
       //   expression. If the identifier is not found, it is then looked up in
       //   the context of the entire postfix-expression and shall name a class
       //   or function template.
-      if (S) LookupName(Found, S);
+      if (S) {
+        MSVCDoNotLookupInInstance QualifiedLookupScope(*this);
+        LookupName(Found, S);
+      }
       ObjectTypeSearchedInScope = true;
       AllowFunctionTemplatesInLookup = false;
     }
   } else if (isDependent && (!S || ObjectType.isNull())) {
     // We cannot look into a dependent object type or nested nme
     // specifier.
     MemberOfUnknownSpecialization = true;
     return;

lib/Sema/SemaTemplateInstantiate.cpp

for (auto *Member : Pattern->decls()) {
     //      class B *g;
     //    };
     // @endcode
     // 'class B' has the template as lexical context but semantically it is
     // introduced in namespace scope.
     if (Member->getDeclContext() != Pattern)
       continue;
 
+    if (getLangOpts().DelayedTemplateParsing && getLangOpts().MSVCCompat &&
+        Member->isImplicit())
+      if (auto *FD = dyn_cast<FunctionDecl>(Member))
+        if (FD->isLateTemplateParsed())
+          continue;
+
     if (Member->isInvalidDecl()) {
       Instantiation->setInvalidDecl();
       continue;
     }
 
     Decl *NewMember = Instantiator.Visit(Member);
     if (NewMember) {
       if (FieldDecl *Field = dyn_cast<FieldDecl>(NewMember)) {

lib/Sema/SemaTemplateInstantiateDecl.cpp

TemplateDeclInstantiator::InitMethodInstantiation(CXXMethodDecl *New,
   New->setAccess(Tmpl->getAccess());
   if (Tmpl->isVirtualAsWritten())
     New->setVirtualAsWritten(true);
 
   // FIXME: New needs a pointer to Tmpl
   return false;
 }
 
+namespace {
+class MSVCTemplateFunctionRebuilderRAII final {
+  Sema &S;
+  FunctionDecl *NewTemplateDecl = nullptr;
+  FunctionDecl *OldMSVCInstantiation = nullptr;
+  FunctionDecl *PatternDecl = nullptr;
+  DeclarationNameInfo NameInfo;
+
+public:
+  MSVCTemplateFunctionRebuilderRAII(Sema &S, FunctionDecl *PatternDecl,
+                                    FunctionDecl *InstDecl)
+      : S(S), OldMSVCInstantiation(S.MSVCInstantiation),
+        PatternDecl(PatternDecl) {
+    if (!S.getLangOpts().DelayedTemplateParsing ||
+        !S.getLangOpts().MSVCCompat || InstDecl->isDependentContext() ||
+        !PatternDecl)
+      return;
+    NameInfo = {PatternDecl->getDeclName(), PatternDecl->getLocation()};
+    ASTContext &C = S.getASTContext();
+    OldMSVCInstantiation = S.MSVCInstantiation;
+    S.MSVCInstantiation = InstDecl;
+
+    if (auto *CD = dyn_cast<CXXConstructorDecl>(PatternDecl)) {
+      NewTemplateDecl = CXXConstructorDecl::Create(
+          C, cast<CXXRecordDecl>(PatternDecl->getParent()), CD->getLocStart(),
+          NameInfo, CD->getType(), CD->getTypeSourceInfo(),
+          CD->isExplicitSpecified(), CD->isInlineSpecified(), CD->isImplicit(),
+          CD->isConstexpr());
+    } else if (auto *DD = dyn_cast<CXXDestructorDecl>(PatternDecl)) {
+      NewTemplateDecl = CXXDestructorDecl::Create(
+          C, cast<CXXRecordDecl>(PatternDecl->getParent()), DD->getLocStart(),
+          NameInfo, DD->getType(), DD->getTypeSourceInfo(),
+          DD->isInlineSpecified(), DD->isImplicit());
+    } else if (auto *CD = dyn_cast<CXXConversionDecl>(PatternDecl)) {
+      NewTemplateDecl = CXXConversionDecl::Create(
+          C, cast<CXXRecordDecl>(PatternDecl->getParent()), CD->getLocStart(),
+          NameInfo, CD->getType(), CD->getTypeSourceInfo(),
+          CD->isInlineSpecified(), CD->isExplicitSpecified(), CD->isConstexpr(),
+          CD->getLocEnd());
+    } else if (auto *MD = dyn_cast<CXXMethodDecl>(PatternDecl)) {
+      NewTemplateDecl = CXXMethodDecl::Create(
+          C, cast<CXXRecordDecl>(PatternDecl->getParent()), MD->getLocStart(),
+          NameInfo, MD->getType(), MD->getTypeSourceInfo(),
+          MD->getStorageClass(), MD->isInlineSpecified(), MD->isConstexpr(),
+          MD->getLocEnd());
+    } else {
+      assert(PatternDecl->getKind() == Decl::Function);
+      NewTemplateDecl = FunctionDecl::Create(
+          C, PatternDecl->getParent(), PatternDecl->getLocStart(), NameInfo,
+          PatternDecl->getType(), PatternDecl->getTypeSourceInfo(),
+          PatternDecl->getStorageClass(), PatternDecl->isInlineSpecified(),
+          PatternDecl->hasWrittenPrototype(), PatternDecl->isConstexpr());
+    }
+    NewTemplateDecl->setAccess(PatternDecl->getAccess());
+    if (PatternDecl->isInlined() && !PatternDecl->isInlineSpecified())
+      NewTemplateDecl->setImplicitlyInline();
+    switch (PatternDecl->getTemplatedKind()) {
+    case FunctionDecl::TK_FunctionTemplate:
+      NewTemplateDecl->setDescribedFunctionTemplate(
+          PatternDecl->getDescribedFunctionTemplate());
+      break;
+    case FunctionDecl::TK_MemberSpecialization:
+      NewTemplateDecl->setInstantiationOfMemberFunction(
+          PatternDecl->getInstantiatedFromMemberFunction(),
+          PatternDecl->getTemplateSpecializationKind());
+      break;
+    case FunctionDecl::TK_FunctionTemplateSpecialization: {
+      const ASTTemplateArgumentListInfo *Info =
+          PatternDecl->getTemplateSpecializationArgsAsWritten();
+      TemplateArgumentListInfo Args(Info->LAngleLoc, Info->RAngleLoc);
+      for (unsigned I = 0, E = Info->NumTemplateArgs; I != E; ++I)
+        Args.addArgument((*Info)[I]);
+      NewTemplateDecl->setFunctionTemplateSpecialization(
+          PatternDecl->getPrimaryTemplate(),
+          PatternDecl->getTemplateSpecializationArgs(), nullptr,
+          PatternDecl->getTemplateSpecializationKind(), &Args,
+          PatternDecl->getPointOfInstantiation());
+      break;
+    }
+    case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
+      UnresolvedSet<4> Decls;
+      DependentFunctionTemplateSpecializationInfo *Info =
+          PatternDecl->getDependentSpecializationInfo();
+      for (unsigned I = 0, E = Info->getNumTemplates(); I != E; ++I)
+        Decls.addDecl(Info->getTemplate(I));
+      TemplateArgumentListInfo Args(Info->getLAngleLoc(), Info->getRAngleLoc());
+      for (unsigned I = 0, E = Info->getNumTemplateArgs(); I != E; ++I)
+        Args.addArgument(Info->getTemplateArg(I));
+      NewTemplateDecl->setDependentTemplateSpecialization(C, Decls, Args);
+      break;
+    }
+    case FunctionDecl::TK_NonTemplate:
+      break;
+    }
+    NewTemplateDecl->setLexicalDeclContext(PatternDecl->getLexicalParent());
+    NewTemplateDecl->setInnerLocStart(PatternDecl->getInnerLocStart());
+    SmallVector<ParmVarDecl *, 4> Params;
+    for (auto *Parm : PatternDecl->parameters()) {
+      auto *NewParm = ParmVarDecl::Create(
+          C, NewTemplateDecl, Parm->getLocStart(), Parm->getLocation(),
+          Parm->getIdentifier(), Parm->getType(), Parm->getTypeSourceInfo(),
+          Parm->getStorageClass(), Parm->getDefaultArg());
+      Params.push_back(NewParm);
+    }
+    if (PatternDecl->getNumTemplateParameterLists() > 0) {
+      SmallVector<TemplateParameterList *, 4> ParameterLists;
+      for (unsigned I = 0, E = PatternDecl->getNumTemplateParameterLists();
+           I < E; ++I)
+        ParameterLists.push_back(PatternDecl->getTemplateParameterList(I));
+      NewTemplateDecl->setTemplateParameterListsInfo(C, ParameterLists);
+    }
+    NewTemplateDecl->setParams(Params);
+    NewTemplateDecl->setLateTemplateParsed(/*ILT=*/true);
+    NewTemplateDecl->setImplicit(/*I=*/true);
+    NewTemplateDecl->setLexicalDeclContext(PatternDecl->getLexicalParent());
+    if (PatternDecl->hasAttrs()) {
+      for (auto *Attr : PatternDecl->attrs())
+        NewTemplateDecl->addAttr(Attr);
+    }
+  }
+  FunctionDecl *getTemplateDecl() const { return NewTemplateDecl; }
+  ~MSVCTemplateFunctionRebuilderRAII() {
+    if (NewTemplateDecl) {
+      assert(S.getLangOpts().DelayedTemplateParsing &&
+             S.getLangOpts().MSVCCompat);
+      NewTemplateDecl->setLateTemplateParsed(/*ILT=*/true);
+      S.MSVCInstantiation = OldMSVCInstantiation;
+      if (NewTemplateDecl->isInvalidDecl())
+        PatternDecl->setInvalidDecl(/*Invalid=*/true);
+    }
+  }
+};
+} // namespace
+
 /// \brief Instantiate the definition of the given function from its
 /// template.
 ///
 /// \param PointOfInstantiation the point at which the instantiation was
 /// required. Note that this is not precisely a "point of instantiation"
 /// for the function, but it's close.
 ///
 /// \param Function the already-instantiated declaration of a
void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
   // while we're still within our own instantiation context.
   // This has to happen before LateTemplateParser below is called, so that
   // it marks vtables used in late parsed templates as used.
   SavePendingLocalImplicitInstantiationsRAII
       SavedPendingLocalImplicitInstantiations(*this);
   SavePendingInstantiationsAndVTableUsesRAII
       SavePendingInstantiationsAndVTableUses(*this, /*Enabled=*/Recursive);
 
+  // Do not perform instantiation in MSVC compatibility mode if function is not
+  // used yet. MSVC instantiates function only if it is used.
+  if (getLangOpts().DelayedTemplateParsing && getLangOpts().MSVCCompat &&
+      (Function->isDependentContext() ||
+       (PatternDecl->isLateTemplateParsed() && !DefinitionRequired &&
+        !PatternDecl->isUsed(/*CheckUsedAttr=*/true) && !Function->isUsed())))
+    return;
   // Call the LateTemplateParser callback if there is a need to late parse
   // a templated function definition.
+  LateParsedTemplate NewLPT;
   if (!Pattern && PatternDecl->isLateTemplateParsed() &&
       LateTemplateParser) {
     // FIXME: Optimize to allow individual templates to be deserialized.
     if (PatternDecl->isFromASTFile())
       ExternalSource->ReadLateParsedTemplates(LateParsedTemplateMap);
 
     LateParsedTemplate *LPT = LateParsedTemplateMap.lookup(PatternDecl);
     assert(LPT && "missing LateParsedTemplate");
-    LateTemplateParser(OpaqueParser, *LPT);
+    NewLPT = *LPT;
+  }
+  MSVCTemplateFunctionRebuilderRAII MSVCRebuilder(
+      *this, NewLPT.D ? NewLPT.D->getAsFunction() : nullptr, Function);
+  if (!Pattern && PatternDecl->isLateTemplateParsed() && LateTemplateParser &&
+      NewLPT.D) {
+    if (getLangOpts().DelayedTemplateParsing && getLangOpts().MSVCCompat) {
+      PatternDecl = MSVCRebuilder.getTemplateDecl();
+      NewLPT.D = MSVCRebuilder.getTemplateDecl();
+    }
+    LateTemplateParser(OpaqueParser, NewLPT);
     Pattern = PatternDecl->getBody(PatternDecl);
   }
 
   // FIXME: Check that the definition is visible before trying to instantiate
   // it. This requires us to track the instantiation stack in order to know
   // which definitions should be visible.
 
   if (!Pattern && !PatternDecl->isDefaulted()) {

lib/Serialization/ASTReader.cpp

 }
 
 Token ASTReader::ReadToken(ModuleFile &F, const RecordDataImpl &Record,
                            unsigned &Idx) {
   Token Tok;
   Tok.startToken();
   Tok.setLocation(ReadSourceLocation(F, Record, Idx));
   Tok.setLength(Record[Idx++]);
+  if (Tok.getLength())
     if (IdentifierInfo *II = getLocalIdentifier(F, Record[Idx++]))
       Tok.setIdentifierInfo(II);
   Tok.setKind((tok::TokenKind)Record[Idx++]);
   Tok.setFlag((Token::TokenFlags)Record[Idx++]);
   return Tok;
 }
 
 MacroInfo *ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset) {
   BitstreamCursor &Stream = F.MacroCursor;
 

lib/Serialization/ASTWriter.cpp

 
 #include "clang/Serialization/AttrPCHWrite.inc"
 
   }
 }
 
 void ASTWriter::AddToken(const Token &Tok, RecordDataImpl &Record) {
   AddSourceLocation(Tok.getLocation(), Record);
+  if (Tok.isAnnotation()) {
+    assert(!Tok.getAnnotationValue());
+    Record.push_back(0);
+  } else {
     Record.push_back(Tok.getLength());
 
     // FIXME: When reading literal tokens, reconstruct the literal pointer
     // if it is needed.
     AddIdentifierRef(Tok.getIdentifierInfo(), Record);
+  }
   // FIXME: Should translate token kind to a stable encoding.
   Record.push_back(Tok.getKind());
   // FIXME: Should translate token flags to a stable encoding.
   Record.push_back(Tok.getFlags());
 }
 
 void ASTWriter::AddString(StringRef Str, RecordDataImpl &Record) {
   Record.push_back(Str.size());

test/SemaCXX/ms-property.cpp

-// RUN: %clang_cc1 -ast-print -verify -triple=x86_64-pc-win32 -fms-compatibility %s -o - | FileCheck %s
-// RUN: %clang_cc1 -triple=x86_64-pc-win32 -fms-compatibility -emit-pch -o %t %s
-// RUN: %clang_cc1 -triple=x86_64-pc-win32 -fms-compatibility -include-pch %t -verify %s -ast-print -o - | FileCheck %s
+// RUN: %clang_cc1 -ast-print -verify -triple=x86_64-pc-win32 -fms-compatibility -fdelayed-template-parsing %s -o - | FileCheck %s
+// RUN: %clang_cc1 -triple=x86_64-pc-win32 -fms-compatibility -fdelayed-template-parsing -emit-pch -o %t %s
+// RUN: %clang_cc1 -triple=x86_64-pc-win32 -fms-compatibility -fdelayed-template-parsing -include-pch %t -verify %s -ast-print -o - | FileCheck %s
 // expected-no-diagnostics
 
 #ifndef HEADER
 #define HEADER
 
 class Test1 {
 private:
   int x_;

 // CHECK: this->x[0][0] = this->x[1][1];
 
 // CHECK-LABEL: main
 int main(int argc, char **argv) {
   S *p1 = 0;
   St<float> *p2 = 0;
   // CHECK: St<int> a;
   St<int> a;
-  // CHECK-NEXT: int j = (p1->x)[223][11];
+  St<float> b;
+  p2 = &b;
+  // CHECK: int j = (p1->x)[223][11];
   int j = (p1->x)[223][11];
   // CHECK-NEXT: (p1->x[23])[1] = j;
   (p1->x[23])[1] = j;
   // CHECK-NEXT: float j1 = (p2->x[223][11]);
   float j1 = (p2->x[223][11]);
   // CHECK-NEXT: ((p2->x)[23])[1] = j1;
   ((p2->x)[23])[1] = j1;
   // CHECK-NEXT: ++(((p2->x)[23])[1]);
   ++(((p2->x)[23])[1]);
   // CHECK-NEXT: j1 = ((p2->x)[23])[1] = j1;
   j1 = ((p2->x)[23])[1] = j1;
   // CHECK-NEXT: return Test1::GetTest1()->X;
   return Test1::GetTest1()->X;
 }
 #endif // HEADER

test/SemaTemplate/lookup-dependent-bases.cpp

-// RUN: %clang_cc1 -fms-compatibility -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fms-compatibility -fdelayed-template-parsing -fsyntax-only -verify %s
 
 namespace basic {
 struct C {
   static void foo2() {}
 };
 template <typename T>
 struct A {
   typedef C D;
 };
 
 template <typename T>
 struct B : A<T> {
   void foo() {
-    D::foo2(); // expected-warning {{use of undeclared identifier 'D'; unqualified lookup into dependent bases of class template 'B' is a Microsoft extension}}
+    D::foo2(); // expected-warning {{use of identifier 'D' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
   }
 };
 
 template struct B<int>; // Instantiation has no warnings.
 }
 
 namespace nested_nodep_base {
-// There are limits to our hacks, MSVC accepts this, but we don't.
 struct A {
   struct D { static void foo2(); };
 };
 template <typename T>
 struct B : T {
   struct C {
     void foo() {
-      D::foo2(); // expected-error {{use of undeclared identifier 'D'}}
+      D::foo2(); // expected-warning {{use of identifier 'D' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
     }
   };
 };
 
 template struct B<A>; // Instantiation has no warnings.
 }
 
 namespace nested_dep_base {
 // We actually accept this because the inner class has a dependent base even
 // though it isn't a template.
 struct A {
   struct D { static void foo2(); };
 };
 template <typename T>
 struct B {
   struct C : T {
     void foo() {
-      D::foo2(); // expected-warning {{use of undeclared identifier 'D'; unqualified lookup into dependent bases of class template 'C' is a Microsoft extension}}
+      D::foo2(); // expected-warning {{use of identifier 'D' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
     }
   };
 };
 
 template struct B<A>; // Instantiation has no warnings.
 }

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

-// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -std=c++1y -fms-compatibility -fno-spell-checking -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -std=c++1y -fms-compatibility -fdelayed-template-parsing -fno-spell-checking -fsyntax-only -verify %s
 
 
 template <class T>
 class A {
 public:
-   void f(T a) { }// expected-note 2{{must qualify identifier to find this declaration in dependent base class}}
-   void g();// expected-note 2{{must qualify identifier to find this declaration in dependent base class}}
+   void f(T a) { }
+   void g();
 };
 
 template <class T>
 class B : public A<T> {
 public:
   void z(T a)
     {
        f(a); // expected-warning 2{{use of identifier 'f' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
        g(); // expected-warning 2{{use of identifier 'g' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
     }
+  B() : A<T>() {}
 };
 
-template class B<int>; // expected-note {{requested here}}
-template class B<char>; // expected-note {{requested here}}
+template class B<int>;
+template class B<char>;
 
 void test()
 {
     B<int> b;
     b.z(3);
 }
 
 struct A2 {
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 templates is a Microsoft extension}}
   }
 };
 
 template class B<int>;
 
 }
 
 
 
 namespace lookup_dependent_base_class_static_function {
 
 template <class T>
 class A {
 public:
-   static void static_func();// expected-note {{must qualify identifier to find this declaration in dependent base class}}
-   void func();// expected-note {{must qualify identifier to find this declaration in dependent base class}}
+   static void static_func();
+   void func();
 };
 
 
 template <class T>
 class B : public A<T> {
 public:
   static void z2(){
     static_func();  // expected-warning {{use of identifier 'static_func' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}

 }
 
 
 namespace lookup_dependent_base_class_friend {
 
 template <class T>
 class B {
 public:
-  static void g();  // expected-note {{must qualify identifier to find this declaration in dependent base class}} 
+  static void g();
 };
 
 template <class T>
 class A : public B<T> {
 public:
   friend void foo(A<T> p){
     g(); // expected-warning {{use of identifier 'g' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
   }
 };
 
 int main2()
 {
   A<int> a;
-  foo(a); // expected-note {{requested here}}
+  foo(a);
 }
 
 }
 
 
 namespace lookup_dependent_base_no_typo_correction {
 
 class C {
 public:
   int m_hWnd;
+  static int c_hWnd;
+};
+
+class B {
+public:
+  static bool b_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 templates is a Microsoft extension}}
+    B::b_hWnd = this->m_hWnd < 0;
+    C::c_hWnd = 0;
   }
 };
 
 template class A<C>;
 
 }
 
 namespace PR12701 {
 
 class A {};
 class B {};
 
 template <class T>
 class Base {
  public:
-  bool base_fun(void* p) { return false; }  // expected-note {{must qualify identifier to find this declaration in dependent base class}}
+  bool base_fun(void* p) { return false; }
   operator T*() const { return 0; }
 };
 
 template <class T>
 class Container : public Base<T> {
  public:
   template <typename S>
   bool operator=(const Container<S>& rhs) {
-    return base_fun(rhs);  // expected-warning {{use of identifier 'base_fun' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
+    return base_fun(rhs);  // expected-warning 2 {{use of identifier 'base_fun' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
   }
 };
 
 void f() {
   Container<A> text_provider;
   Container<B> text_provider2;
-  text_provider2 = text_provider;  // expected-note {{in instantiation of function template specialization}}
+  text_provider2 = text_provider;
 }
 
 }  // namespace PR12701
 
 namespace PR16014 {
 
 struct A {
   int a;
   static int sa;
 };
 template <typename T> struct B : T {
   int     foo() { return a; }           // expected-warning {{lookup into dependent bases}}
-  int    *bar() { return &a; }          // expected-warning {{lookup into dependent bases}}
+  int    *bar() { return &a; }          // expected-warning {{lookup into dependent bases}} expected-error {{cannot initialize return object of type 'int *' with an rvalue of type 'int PR16014::A::*'}}
   int     baz() { return T::a; }
   int T::*qux() { return &T::a; }
   static int T::*stuff() { return &T::a; }
   static int stuff1() { return T::sa; }
   static int *stuff2() { return &T::sa; }
   static int stuff3() { return sa; }    // expected-warning {{lookup into dependent bases}}
   static int *stuff4() { return &sa; }  // expected-warning {{lookup into dependent bases}}
 };
 
 template <typename T> struct C : T {
-  int     foo() { return b; }      // expected-error {{no member named 'b' in 'PR16014::C<PR16014::A>'}} expected-warning {{lookup into dependent bases}}
-  int    *bar() { return &b; }     // expected-error {{no member named 'b' in 'PR16014::C<PR16014::A>'}} expected-warning {{lookup into dependent bases}}
+  int     foo() { return b; }      // expected-error {{use of undeclared identifier 'b'}}
+  int    *bar() { return &b; }     // expected-error {{use of undeclared identifier 'b'}}
   int     baz() { return T::b; }   // expected-error {{no member named 'b' in 'PR16014::A'}}
   int T::*qux() { return &T::b; }  // expected-error {{no member named 'b' in 'PR16014::A'}}
   int T::*fuz() { return &U::a; }  // expected-error {{use of undeclared identifier 'U'}} \
   // expected-warning {{unqualified lookup into dependent bases of class template 'C'}}
 };
 
-template struct B<A>;
+template struct B<A>; // expected-note {{in instantiation of member function 'PR16014::B<PR16014::A>::bar' requested here}}
 template struct C<A>;  // expected-note-re 1+ {{in instantiation of member function 'PR16014::C<PR16014::A>::{{.*}}' requested here}}
 
 template <typename T> struct D : T {
   struct Inner {
     int foo() {
-      // FIXME: MSVC can find this in D's base T!  Even worse, if ::sa exists,
-      // clang will use it instead.
-      return sa; // expected-error {{use of undeclared identifier 'sa'}}
+      return sa; // expected-warning {{use of identifier 'sa' found via unqualified lookup into dependent bases of class templates is a Microsoft extension}}
     }
   };
 };
 template struct D<A>;
 
 }
 
 namespace PR19233 {
 template <class T>
 struct A : T {
   void foo() {
-    ::undef(); // expected-error {{no member named 'undef' in the global namespace}}
+    ::undef(); // expected-error 2 {{no member named 'undef' in the global namespace}}
   }
   void bar() {
-    ::UndefClass::undef(); // expected-error {{no member named 'UndefClass' in the global namespace}}
+    ::UndefClass::undef(); // expected-error 2 {{no member named 'UndefClass' in the global namespace}}
   }
   void baz() {
-    B::qux(); // expected-error {{use of undeclared identifier 'B'}} \
-    // expected-warning {{unqualified lookup into dependent bases of class template 'A'}}
+    B::qux(); // expected-error {{'PR19233::B::qux' is not a member of class 'PR19233::A<PR19233::D>'}}
   }
 };
 
 struct B { void qux(); };
 struct C : B { };
 template struct A<C>; // No error!  B is a base of A<C>, and qux is available.
 
 struct D { };
static void funcLocalClass() {
     struct X {
       NameFromBase x; // expected-warning {{lookup into dependent bases}}
     } y;
   }
 
   void localClassMethod() {
     struct X {
       void bar() {
-        NameFromBase m; // expected-warning {{lookup into dependent bases}}
+        NameFromBase m;
       }
     } x;
     x.bar();
   }
 
   static void funcLambda() {
     auto l = []() {
       NameFromBase x; // expected-warning {{lookup into dependent bases}}
template <typename T> struct D : C<T> {
   // expected-warning@+1 {{use of undeclared identifier 'NameFromBase'; 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'}}
-  UndefVar.method(); // expected-error {{use of undeclared identifier 'UndefVar'}}
+  Undef::staticMethod();
+  UndefVar.method();
 }
 }
 
 namespace PR20716 {
 template <template <typename T> class A>
 struct B : A<int>
 {
   XXX x; // expected-error {{unknown type name}}

 {
   XXX x; // expected-error {{unknown type name}}
 };
 }
 
 namespace PR23810 {
 void f(int);
 struct Base {
-  void f(); // expected-note{{must qualify identifier to find this declaration in dependent base class}}
+  void f();
 };
 template <typename T> struct Template : T {
   void member() {
     f(); // expected-warning {{found via unqualified lookup into dependent bases}}
   }
 };
 void test() {
   Template<Base> x;
-  x.member(); // expected-note{{requested here}}
+  x.member();
 };
 }
 
 namespace PR23823 {
 // Don't delay lookup in SFINAE context.
 template <typename T> decltype(g(T())) check(); // expected-note{{candidate template ignored: substitution failure [with T = int]: use of undeclared identifier 'g'}}
 decltype(check<int>()) x; // expected-error{{no matching function for call to 'check'}}
 
 void h();
 template <typename T> decltype(h(T())) check2(); // expected-note{{candidate template ignored: substitution failure [with T = int]: no matching function for call to 'h'}}
 decltype(check2<int>()) y; // expected-error{{no matching function for call to 'check2'}}
 }
 
 // We also allow unqualified lookup into bases in contexts where the we know the
 // undeclared identifier *must* be a type, such as a new expression or catch
 // parameter type.
 template <typename T>
 struct UseUnqualifiedTypeNames : T {
   void foo() {
-    void *P = new TheType; // expected-warning {{unqualified lookup}} expected-error {{no type}}
-    size_t x = __builtin_offsetof(TheType, f2); // expected-warning {{unqualified lookup}} expected-error {{no type}}
+    void *P = new TheType; // expected-warning 2 {{unqualified lookup}} expected-error {{no type}}
+    size_t x = __builtin_offsetof(TheType, f2); // expected-warning 2 {{unqualified lookup}} expected-error {{no type}}
     try {
-    } catch (TheType) { // expected-warning {{unqualified lookup}} expected-error {{no type}}
+    } catch (TheType) { // expected-warning 2 {{unqualified lookup}} expected-error {{no type}}
     }
-    enum E : IntegerType { E0 = 42 }; // expected-warning {{unqualified lookup}} expected-error {{no type}}
-    _Atomic(TheType) a; // expected-warning {{unqualified lookup}} expected-error {{no type}}
+    enum E : IntegerType { E0 = 42 }; // expected-warning 2 {{unqualified lookup}} expected-error {{no type}}
+    _Atomic(TheType) a; // expected-warning 2 {{unqualified lookup}} expected-error {{no type}}
   }
   void out_of_line();
 };
 template <typename T>
 void UseUnqualifiedTypeNames<T>::out_of_line() {
-  void *p = new TheType; // expected-warning {{unqualified lookup}} expected-error {{no type}}
+  void *p = new TheType; // expected-warning 2 {{unqualified lookup}} expected-error {{no type}}
 }
 struct Base {
   typedef int IntegerType;
   struct TheType {
     int f1, f2;
   };
 };
 template struct UseUnqualifiedTypeNames<Base>;

test/SemaTemplate/typename-specifier.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s -Wno-unused
-// RUN: %clang_cc1 -fsyntax-only -verify %s -Wno-unused -fms-compatibility -DMSVC
+// RUN: %clang_cc1 -fsyntax-only -verify %s -Wno-unused -fms-compatibility -fdelayed-template-parsing -DMSVC
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s -Wno-unused
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s -Wno-unused -fms-compatibility -DMSVC
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s -Wno-unused -fms-compatibility -fdelayed-template-parsing -DMSVC
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s -Wno-unused
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s -Wno-unused -fms-compatibility -DMSVC
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s -Wno-unused -fms-compatibility -fdelayed-template-parsing -DMSVC
 namespace N {
   struct A {
     typedef int type;
   };
 
   struct B {
   };
 
namespace PR10925 {
   template<class ctype, int mydim, int coorddim>
   class MockGeometry : BasicGeometry<mydim, int>{
     using typename BasicGeometry<mydim, int>::operator[]; // expected-error {{typename is allowed for identifiers only}}
   };
 }
 
 
 namespace missing_typename {
-template <class T1, class T2> struct pair {}; // expected-note 7 {{template parameter is declared here}}
+#ifdef MSVC
+// expected-note@+4 3 {{template parameter is declared here}}
+#else
+// expected-note@+2 7 {{template parameter is declared here}}
+#endif // MSVC
+template <class T1, class T2> struct pair {};
 
 template <class T1, class T2>
 struct map {
   typedef T1* iterator;
 };
 
 template <class T>
 class ExampleClass1 {
   struct ExampleItem;
 
 
   struct ExampleItemSet {
     typedef ExampleItem* iterator;
     ExampleItem* operator[](unsigned);
   };
 
   void foo() {
-#ifdef MSVC
-    // expected-warning@+4 {{omitted 'typename' is a Microsoft extension}}
-#else
+#ifndef MSVC
     // expected-error@+2 {{template argument for template type parameter must be a type; did you forget 'typename'?}}
 #endif
     pair<ExampleItemSet::iterator, int> i;
-    pair<this->ExampleItemSet::iterator, int> i; // expected-error-re {{template argument for template type parameter must be a type{{$}}}}
-    pair<ExampleItemSet::operator[], int> i; // expected-error-re {{template argument for template type parameter must be a type{{$}}}}
+#ifndef MSVC
+    // expected-error-re@+2 {{template argument for template type parameter must be a type{{$}}}}}
+#endif
+    pair<this->ExampleItemSet::iterator, int> i;
+#ifndef MSVC
+    // expected-error-re@+2 {{template argument for template type parameter must be a type{{$}}}}}
+#endif
+    pair<ExampleItemSet::operator[], int> i;
   }
 #ifdef MSVC
     // expected-warning@+4 {{omitted 'typename' is a Microsoft extension}}
 #else
   // expected-error@+2 {{template argument for template type parameter must be a type; did you forget 'typename'?}}
 #endif
   pair<ExampleItemSet::iterator, int> elt;
 
 
   typedef map<int, ExampleItem*> ExampleItemMap;
 
   static void bar() {
-#ifdef MSVC
-    // expected-warning@+4 {{omitted 'typename' is a Microsoft extension}}
-#else
+#ifndef MSVC
     // expected-error@+2 {{template argument for template type parameter must be a type; did you forget 'typename'?}}
 #endif
     pair<ExampleItemMap::iterator, int> i;
   }
 #ifdef MSVC
     // expected-warning@+4 {{omitted 'typename' is a Microsoft extension}}
 #else
   // expected-error@+2 {{template argument for template type parameter must be a type; did you forget 'typename'?}}