clang: fix early substitution of alias templates

[mizvekov]

Summary

When substituting alias templates, we stop bumping up template
parameters below current substitution level.

Fixes PR55886.

Signed-off-by: Matheus Izvekov <[e-mail]>

[mizvekov]

.

[mizvekov]

.

[mizvekov]

.

[mizvekov]

.

[mizvekov]

@rsmith , I have marked the few spots where the change is meaningful.

clang/include/clang/Sema/Template.h

488–497

mark

629–648

mark

clang/lib/Sema/SemaTemplateInstantiate.cpp

931–941

mark

1194–1216

mark

1872–1873

mark

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

2807–2808

mark

2965–2971

mark

3105–3109

mark

clang/test/AST/ast-dump-template-decls.cpp

124

mark

[mizvekov]

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

1060

mark

[mizvekov]

.

[rsmith]

clang/lib/Sema/SemaTemplateInstantiate.cpp

1872–1873

Instead of adding the new EarlySubstitution flag and wiring it through everywhere, can you use the existing MultiLevelTemplateArgumentList::getNewDepth function? That already handles the case of a depth that's within the number of retained outer levels. We might need to set the number of retained outer levels properly when doing alias template substitution; I'm not sure if we do so currently and I suspect we don't.

[mizvekov]

clang/lib/Sema/SemaTemplateInstantiate.cpp

1872–1873

I think we do set the number of outer levels correctly when substituting within the type of alias templates, circa SemaTemplate.cpp:3718:

// Only substitute for the innermost template argument list.
MultiLevelTemplateArgumentList TemplateArgLists;
TemplateArgLists.addOuterTemplateArguments(&StackTemplateArgs);
TemplateArgLists.addOuterRetainedLevels(
    AliasTemplate->getTemplateParameters()->getDepth());

What the flag was done to deal with is what happens in TemplateDeclInstantiator::VisitTypeAliasTemplateDecl, when replacing just the inner level. We need to substitute there without changing any depths, including the template parameters of the alias itself, and I could not find a way to do that without extending it with the new flag.

Anyway, I will think about this again.
I ended up finding another test case which this patch only partially helps, so I have been back investigating this problem again: https://godbolt.org/z/9fGb1KKvq

template <typename... As> struct Y;
template <typename ...Bs> using Z = Y<Bs...>;
template <typename ...Cs> struct foo {
  template <typename ...Ds> using bind = Z<Ds..., Cs...>;
};
using U = foo<int>::bind<char>;

[mizvekov]

clang/lib/Sema/SemaTemplateInstantiate.cpp

1872–1873

Though that last test case seems actually to be a wrong index problem, not wrong depth.

[mizvekov]

• much smaller patch, puts the new flag as a mutable member of MultiLevelTemplateArgumentList

[mizvekov]

clang/lib/Sema/SemaTemplateInstantiate.cpp

1872–1873

That last new test case hits an unrelated problem besides this one, so I will deal with it in a separate patch.

[mizvekov]

rebase

[mizvekov]

rebase

clang/include/clang/Sema/Sema.h

llvm::ContextualFoldingSet<ConstraintSatisfaction, const ASTContext &>
       SatisfactionCache;
 
   /// Introduce the instantiated function parameters into the local
   /// instantiation scope, and set the parameter names to those used
   /// in the template.
   bool addInstantiatedParametersToScope(
       FunctionDecl *Function, const FunctionDecl *PatternDecl,
       LocalInstantiationScope &Scope,
-      const MultiLevelTemplateArgumentList &TemplateArgs);
+      const MultiLevelTemplateArgumentList &TemplateArgs,
+      bool EarlySubstitution);
 
 public:
   const NormalizedConstraint *
   getNormalizedAssociatedConstraints(
       NamedDecl *ConstrainedDecl, ArrayRef<const Expr *> AssociatedConstraints);
 
   /// \brief Check whether the given declaration's associated constraints are
   /// at least as constrained than another declaration's according to the
bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass,
                                      const PartialDiagnostic &Diag);
   bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass,
                                      DeclAccessPair Found,
                                      QualType ObjectType) {
     return isMemberAccessibleForDeletion(NamingClass, Found, ObjectType,
                                          SourceLocation(), PDiag());
   }
 
-  void HandleDependentAccessCheck(const DependentDiagnostic &DD,
-                         const MultiLevelTemplateArgumentList &TemplateArgs);
-  void PerformDependentDiagnostics(const DeclContext *Pattern,
-                        const MultiLevelTemplateArgumentList &TemplateArgs);
+  void
+  HandleDependentAccessCheck(const DependentDiagnostic &DD,
+                             const MultiLevelTemplateArgumentList &TemplateArgs,
+                             bool EarlySubstitution);
+  void PerformDependentDiagnostics(
+      const DeclContext *Pattern,
+      const MultiLevelTemplateArgumentList &TemplateArgs,
+      bool EarlySubstitution);
 
   void HandleDelayedAccessCheck(sema::DelayedDiagnostic &DD, Decl *Ctx);
 
   /// When true, access checking violations are treated as SFINAE
   /// failures rather than hard errors.
   bool AccessCheckingSFINAE;
 
   enum AbstractDiagSelID {
getPointerOrNull(unsigned numParams) {
       return Infos.data();
     }
   };
 
   void PerformPendingInstantiations(bool LocalOnly = false);
 
   TypeSourceInfo *SubstType(TypeSourceInfo *T,
                             const MultiLevelTemplateArgumentList &TemplateArgs,
-                            SourceLocation Loc, DeclarationName Entity,
-                            bool AllowDeducedTST = false);
+                            bool EarlySubstitution, SourceLocation Loc,
+                            DeclarationName Entity, bool AllowDeducedTST);
 
   QualType SubstType(QualType T,
                      const MultiLevelTemplateArgumentList &TemplateArgs,
-                     SourceLocation Loc, DeclarationName Entity);
+                     bool EarlySubstitution, SourceLocation Loc,
+                     DeclarationName Entity);
 
   TypeSourceInfo *SubstType(TypeLoc TL,
                             const MultiLevelTemplateArgumentList &TemplateArgs,
-                            SourceLocation Loc, DeclarationName Entity);
+                            bool EarlySubstitution, SourceLocation Loc,
+                            DeclarationName Entity);
 
-  TypeSourceInfo *SubstFunctionDeclType(TypeSourceInfo *T,
-                            const MultiLevelTemplateArgumentList &TemplateArgs,
-                                        SourceLocation Loc,
-                                        DeclarationName Entity,
-                                        CXXRecordDecl *ThisContext,
-                                        Qualifiers ThisTypeQuals);
+  TypeSourceInfo *SubstFunctionDeclType(
+      TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs,
+      bool EarlySubstitution, SourceLocation Loc, DeclarationName Entity,
+      CXXRecordDecl *ThisContext, Qualifiers ThisTypeQuals);
   void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto,
-                          const MultiLevelTemplateArgumentList &Args);
+                          const MultiLevelTemplateArgumentList &Args,
+                          bool EarlySubstitution);
   bool SubstExceptionSpec(SourceLocation Loc,
                           FunctionProtoType::ExceptionSpecInfo &ESI,
                           SmallVectorImpl<QualType> &ExceptionStorage,
-                          const MultiLevelTemplateArgumentList &Args);
-  ParmVarDecl *SubstParmVarDecl(ParmVarDecl *D,
-                            const MultiLevelTemplateArgumentList &TemplateArgs,
-                                int indexAdjustment,
-                                Optional<unsigned> NumExpansions,
-                                bool ExpectParameterPack);
+                          const MultiLevelTemplateArgumentList &Args,
+                          bool EarlySubstitution);
+  ParmVarDecl *
+  SubstParmVarDecl(ParmVarDecl *D,
+                   bool EarlySubstitution, int indexAdjustment,
+                   Optional<unsigned> NumExpansions, bool ExpectParameterPack);
   bool SubstParmTypes(SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
                       const FunctionProtoType::ExtParameterInfo *ExtParamInfos,
                       const MultiLevelTemplateArgumentList &TemplateArgs,
+                      bool EarlySubstitution,
                       SmallVectorImpl<QualType> &ParamTypes,
                       SmallVectorImpl<ParmVarDecl *> *OutParams,
                       ExtParameterInfoBuilder &ParamInfos);
   ExprResult SubstExpr(Expr *E,
-                       const MultiLevelTemplateArgumentList &TemplateArgs);
+                       const MultiLevelTemplateArgumentList &TemplateArgs,
+                       bool EarlySubstitution);
 
   /// Substitute the given template arguments into a list of
   /// expressions, expanding pack expansions if required.
   ///
   /// \param Exprs The list of expressions to substitute into.
   ///
   /// \param IsCall Whether this is some form of call, in which case
   /// default arguments will be dropped.
   ///
   /// \param TemplateArgs The set of template arguments to substitute.
   ///
   /// \param Outputs Will receive all of the substituted arguments.
   ///
   /// \returns true if an error occurred, false otherwise.
   bool SubstExprs(ArrayRef<Expr *> Exprs, bool IsCall,
                   const MultiLevelTemplateArgumentList &TemplateArgs,
-                  SmallVectorImpl<Expr *> &Outputs);
+                  bool EarlySubstitution, SmallVectorImpl<Expr *> &Outputs);
 
   StmtResult SubstStmt(Stmt *S,
-                       const MultiLevelTemplateArgumentList &TemplateArgs);
+                       const MultiLevelTemplateArgumentList &TemplateArgs,
+                       bool EarlySubstitution);
 
   TemplateParameterList *
   SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner,
-                      const MultiLevelTemplateArgumentList &TemplateArgs);
+                      const MultiLevelTemplateArgumentList &TemplateArgs,
+                      bool EarlySubstitution);
 
   bool
   SubstTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
                          const MultiLevelTemplateArgumentList &TemplateArgs,
+                         bool EarlySubstitution,
                          TemplateArgumentListInfo &Outputs);
 
-
   Decl *SubstDecl(Decl *D, DeclContext *Owner,
-                  const MultiLevelTemplateArgumentList &TemplateArgs);
+                  const MultiLevelTemplateArgumentList &TemplateArgs,
+                  bool EarlySubstitution);
 
   /// Substitute the name and return type of a defaulted 'operator<=>' to form
   /// an implicit 'operator=='.
   FunctionDecl *SubstSpaceshipAsEqualEqual(CXXRecordDecl *RD,
                                            FunctionDecl *Spaceship);
 
-  ExprResult SubstInitializer(Expr *E,
-                       const MultiLevelTemplateArgumentList &TemplateArgs,
-                       bool CXXDirectInit);
+  ExprResult
+  SubstInitializer(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs,
+                   bool EarlySubstitution, bool CXXDirectInit);
 
-  bool
-  SubstBaseSpecifiers(CXXRecordDecl *Instantiation,
-                      CXXRecordDecl *Pattern,
-                      const MultiLevelTemplateArgumentList &TemplateArgs);
+  bool SubstBaseSpecifiers(CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
+                           const MultiLevelTemplateArgumentList &TemplateArgs,
+                           bool EarlySubstitution);
 
-  bool
-  InstantiateClass(SourceLocation PointOfInstantiation,
+  bool InstantiateClass(SourceLocation PointOfInstantiation,
                         CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
                         const MultiLevelTemplateArgumentList &TemplateArgs,
-                   TemplateSpecializationKind TSK,
-                   bool Complain = true);
+                        bool EarlySubstitution, TemplateSpecializationKind TSK,
+                        bool Complain);
 
   bool InstantiateEnum(SourceLocation PointOfInstantiation,
                        EnumDecl *Instantiation, EnumDecl *Pattern,
                        const MultiLevelTemplateArgumentList &TemplateArgs,
-                       TemplateSpecializationKind TSK);
+                       bool EarlySubstitution, TemplateSpecializationKind TSK);
 
   bool InstantiateInClassInitializer(
       SourceLocation PointOfInstantiation, FieldDecl *Instantiation,
-      FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs);
+      FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs,
+      bool EarlySubstitution);
 
   struct LateInstantiatedAttribute {
     const Attr *TmplAttr;
     LocalInstantiationScope *Scope;
     Decl *NewDecl;
 
     LateInstantiatedAttribute(const Attr *A, LocalInstantiationScope *S,
                               Decl *D)
       : TmplAttr(A), Scope(S), NewDecl(D)
     { }
   };
   typedef SmallVector<LateInstantiatedAttribute, 16> LateInstantiatedAttrVec;
 
   void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
-                        const Decl *Pattern, Decl *Inst,
-                        LateInstantiatedAttrVec *LateAttrs = nullptr,
-                        LocalInstantiationScope *OuterMostScope = nullptr);
+                        bool EarlySubstitution, const Decl *Pattern, Decl *Inst,
+                        LateInstantiatedAttrVec *LateAttrs,
+                        LocalInstantiationScope *OuterMostScope);
 
   void
   InstantiateAttrsForDecl(const MultiLevelTemplateArgumentList &TemplateArgs,
-                          const Decl *Pattern, Decl *Inst,
-                          LateInstantiatedAttrVec *LateAttrs = nullptr,
-                          LocalInstantiationScope *OuterMostScope = nullptr);
+                          bool EarlySubstitution, const Decl *Pattern,
+                          Decl *Inst, LateInstantiatedAttrVec *LateAttrs,
+                          LocalInstantiationScope *OuterMostScope);
 
   void InstantiateDefaultCtorDefaultArgs(CXXConstructorDecl *Ctor);
 
   bool usesPartialOrExplicitSpecialization(
       SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec);
 
   bool
   InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation,
                            ClassTemplateSpecializationDecl *ClassTemplateSpec,
                            TemplateSpecializationKind TSK,
                            bool Complain = true);
 
-  void InstantiateClassMembers(SourceLocation PointOfInstantiation,
-                               CXXRecordDecl *Instantiation,
-                            const MultiLevelTemplateArgumentList &TemplateArgs,
-                               TemplateSpecializationKind TSK);
+  void InstantiateClassMembers(
+      SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation,
+      bool EarlySubstitution, TemplateSpecializationKind TSK);
 
   void InstantiateClassTemplateSpecializationMembers(
                                           SourceLocation PointOfInstantiation,
                            ClassTemplateSpecializationDecl *ClassTemplateSpec,
                                                 TemplateSpecializationKind TSK);
 
-  NestedNameSpecifierLoc
-  SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
-                           const MultiLevelTemplateArgumentList &TemplateArgs);
+  NestedNameSpecifierLoc SubstNestedNameSpecifierLoc(
+      NestedNameSpecifierLoc NNS,
+      const MultiLevelTemplateArgumentList &TemplateArgs,
+      bool EarlySubstitution);
 
   DeclarationNameInfo
   SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
-                           const MultiLevelTemplateArgumentList &TemplateArgs);
+                           const MultiLevelTemplateArgumentList &TemplateArgs,
+                           bool EarlySubstitution);
   TemplateName
   SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name,
                     SourceLocation Loc,
-                    const MultiLevelTemplateArgumentList &TemplateArgs);
+                    const MultiLevelTemplateArgumentList &TemplateArgs,
+                    bool EarlySubstitution);
 
   bool SubstTypeConstraint(TemplateTypeParmDecl *Inst, const TypeConstraint *TC,
-                           const MultiLevelTemplateArgumentList &TemplateArgs);
+                           const MultiLevelTemplateArgumentList &TemplateArgs,
+                           bool EarlySubstitution);
 
   bool InstantiateDefaultArgument(SourceLocation CallLoc, FunctionDecl *FD,
                                   ParmVarDecl *Param);
   void InstantiateExceptionSpec(SourceLocation PointOfInstantiation,
                                 FunctionDecl *Function);
   bool CheckInstantiatedFunctionTemplateConstraints(
       SourceLocation PointOfInstantiation, FunctionDecl *Decl,
       ArrayRef<TemplateArgument> TemplateArgs,
       ConstraintSatisfaction &Satisfaction);
   FunctionDecl *InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD,
                                                const TemplateArgumentList *Args,
+                                               bool EarlySubstitution,
                                                SourceLocation Loc);
   void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
                                      FunctionDecl *Function,
                                      bool Recursive = false,
                                      bool DefinitionRequired = false,
                                      bool AtEndOfTU = false);
   VarTemplateSpecializationDecl *BuildVarTemplateInstantiation(
       VarTemplateDecl *VarTemplate, VarDecl *FromVar,
       const TemplateArgumentList &TemplateArgList,
       const TemplateArgumentListInfo &TemplateArgsInfo,
       SmallVectorImpl<TemplateArgument> &Converted,
       SourceLocation PointOfInstantiation,
       LateInstantiatedAttrVec *LateAttrs = nullptr,
       LocalInstantiationScope *StartingScope = nullptr);
   VarTemplateSpecializationDecl *CompleteVarTemplateSpecializationDecl(
       VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl,
-      const MultiLevelTemplateArgumentList &TemplateArgs);
-  void
-  BuildVariableInstantiation(VarDecl *NewVar, VarDecl *OldVar,
-                             const MultiLevelTemplateArgumentList &TemplateArgs,
-                             LateInstantiatedAttrVec *LateAttrs,
-                             DeclContext *Owner,
-                             LocalInstantiationScope *StartingScope,
-                             bool InstantiatingVarTemplate = false,
-                             VarTemplateSpecializationDecl *PrevVTSD = nullptr);
+      bool EarlySubstitution);
+  void BuildVariableInstantiation(
+      VarDecl *NewVar, VarDecl *OldVar,
+      const MultiLevelTemplateArgumentList &TemplateArgs,
+      bool EarlySubstitution, LateInstantiatedAttrVec *LateAttrs,
+      DeclContext *Owner, LocalInstantiationScope *StartingScope,
+      bool InstantiatingVarTemplate, VarTemplateSpecializationDecl *PrevVTSD);
 
   void InstantiateVariableInitializer(
       VarDecl *Var, VarDecl *OldVar,
-      const MultiLevelTemplateArgumentList &TemplateArgs);
+      const MultiLevelTemplateArgumentList &TemplateArgs,
+      bool EarlySubstitution);
   void InstantiateVariableDefinition(SourceLocation PointOfInstantiation,
                                      VarDecl *Var, bool Recursive = false,
                                      bool DefinitionRequired = false,
                                      bool AtEndOfTU = false);
 
-  void InstantiateMemInitializers(CXXConstructorDecl *New,
-                                  const CXXConstructorDecl *Tmpl,
-                            const MultiLevelTemplateArgumentList &TemplateArgs);
+  void
+  InstantiateMemInitializers(CXXConstructorDecl *New,
+                             const MultiLevelTemplateArgumentList &TemplateArgs,
+                             bool EarlySubstitution);
 
-  NamedDecl *FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D,
-                          const MultiLevelTemplateArgumentList &TemplateArgs,
-                          bool FindingInstantiatedContext = false);
-  DeclContext *FindInstantiatedContext(SourceLocation Loc, DeclContext *DC,
-                          const MultiLevelTemplateArgumentList &TemplateArgs);
+  NamedDecl *
+  FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D,
+                       bool EarlySubstitution, bool FindingInstantiatedContext);
+  DeclContext *
+  FindInstantiatedContext(SourceLocation Loc, DeclContext *DC,
+                          const MultiLevelTemplateArgumentList &TemplateArgs,
+                          bool EarlySubstitution);
 
   // Objective-C declarations.
   enum ObjCContainerKind {
     OCK_None = -1,
     OCK_Interface = 0,
     OCK_Protocol,
     OCK_Category,
     OCK_ClassExtension,

clang/include/clang/Sema/Template.h

class TemplateDeclInstantiator
     /// A list of out-of-line variable template partial
     /// specializations that will need to be instantiated after the
     /// enclosing variable's instantiation is complete.
     /// FIXME: Verify that this is needed.
     SmallVector<
         std::pair<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>, 4>
     OutOfLineVarPartialSpecs;
 
+    bool EarlySubstitution;
+
   public:
     TemplateDeclInstantiator(Sema &SemaRef, DeclContext *Owner,
-                             const MultiLevelTemplateArgumentList &TemplateArgs)
+                             const MultiLevelTemplateArgumentList &TemplateArgs,
+                             bool EarlySubstitution)
         : SemaRef(SemaRef),
           SubstIndex(SemaRef, SemaRef.ArgumentPackSubstitutionIndex),
-          Owner(Owner), TemplateArgs(TemplateArgs) {}
+          Owner(Owner), TemplateArgs(TemplateArgs),
+          EarlySubstitution(EarlySubstitution) {}
 
 // Define all the decl visitors using DeclNodes.inc
 #define DECL(DERIVED, BASE) \
     Decl *Visit ## DERIVED ## Decl(DERIVED ## Decl *D);
 #define ABSTRACT_DECL(DECL)
 
 // Decls which never appear inside a class or function.
 #define OBJCCONTAINER(DERIVED, BASE)
InstantiateVarTemplatePartialSpecialization(
         VarTemplateDecl *VarTemplate,
         VarTemplatePartialSpecializationDecl *PartialSpec);
     void InstantiateEnumDefinition(EnumDecl *Enum, EnumDecl *Pattern);
 
   private:
     template<typename T>
     Decl *instantiateUnresolvedUsingDecl(T *D,
                                          bool InstantiatingPackElement = false);
+
+    unsigned getNewDepth(unsigned Depth) const {
+      return Depth -
+             (EarlySubstitution ? 0 : TemplateArgs.getNumSubstitutedLevels());
+    }
+
+    class EarlySubstitutionRAII {
+      bool *EarlySubstitution, OldEarlySubstitution;
+      friend class TemplateDeclInstantiator;
+
+      EarlySubstitutionRAII(bool &EarlySubstitution)
+          : EarlySubstitution(&EarlySubstitution),
+            OldEarlySubstitution(std::exchange(EarlySubstitution, true)) {}
+
+    public:
+      ~EarlySubstitutionRAII() { *EarlySubstitution = OldEarlySubstitution; }
+    };
+    EarlySubstitutionRAII getEarlySubstitutionRAII() {
+      return EarlySubstitution;
+    }
   };
 
 } // namespace clang
 
 #endif // LLVM_CLANG_SEMA_TEMPLATE_H

clang/lib/Sema/SemaAccess.cpp

void Sema::HandleDelayedAccessCheck(DelayedDiagnostic &DD, Decl *D) {
   EffectiveContext EC(DC);
 
   AccessTarget Target(DD.getAccessData());
 
   if (CheckEffectiveAccess(*this, EC, DD.Loc, Target) == ::AR_inaccessible)
     DD.Triggered = true;
 }
 
-void Sema::HandleDependentAccessCheck(const DependentDiagnostic &DD,
-                        const MultiLevelTemplateArgumentList &TemplateArgs) {
+void Sema::HandleDependentAccessCheck(
+    const DependentDiagnostic &DD,
+    const MultiLevelTemplateArgumentList &TemplateArgs,
+    bool EarlySubstitution) {
   SourceLocation Loc = DD.getAccessLoc();
   AccessSpecifier Access = DD.getAccess();
 
   Decl *NamingD = FindInstantiatedDecl(Loc, DD.getAccessNamingClass(),
-                                       TemplateArgs);
+                                       TemplateArgs, EarlySubstitution,
+                                       /*FindingInstantiatedContext=*/false);
   if (!NamingD) return;
-  Decl *TargetD = FindInstantiatedDecl(Loc, DD.getAccessTarget(),
-                                       TemplateArgs);
+  Decl *TargetD = FindInstantiatedDecl(Loc, DD.getAccessTarget(), TemplateArgs,
+                                       EarlySubstitution,
+                                       /*FindingInstantiatedContext=*/false);
   if (!TargetD) return;
 
   if (DD.isAccessToMember()) {
     CXXRecordDecl *NamingClass = cast<CXXRecordDecl>(NamingD);
     NamedDecl *TargetDecl = cast<NamedDecl>(TargetD);
     QualType BaseObjectType = DD.getAccessBaseObjectType();
     if (!BaseObjectType.isNull()) {
-      BaseObjectType = SubstType(BaseObjectType, TemplateArgs, Loc,
-                                 DeclarationName());
+      BaseObjectType = SubstType(BaseObjectType, TemplateArgs,
+                                 EarlySubstitution, Loc, DeclarationName());
       if (BaseObjectType.isNull()) return;
     }
 
     AccessTarget Entity(Context,
                         AccessTarget::Member,
                         NamingClass,
                         DeclAccessPair::make(TargetDecl, Access),
                         BaseObjectType);

clang/lib/Sema/SemaCXXScopeSpec.cpp

if (EnumD->isCompleteDefinition()) {
     return false;
   }
 
   // Try to instantiate the definition, if this is a specialization of an
   // enumeration temploid.
   if (EnumDecl *Pattern = EnumD->getInstantiatedFromMemberEnum()) {
     MemberSpecializationInfo *MSI = EnumD->getMemberSpecializationInfo();
     if (MSI->getTemplateSpecializationKind() != TSK_ExplicitSpecialization) {
-      if (InstantiateEnum(L, EnumD, Pattern,
-                          getTemplateInstantiationArgs(EnumD),
-                          TSK_ImplicitInstantiation)) {
+      if (InstantiateEnum(
+              L, EnumD, Pattern, getTemplateInstantiationArgs(EnumD),
+              /*EarlySubstitution=*/false, TSK_ImplicitInstantiation)) {
         if (SS)
           SS->SetInvalid(SS->getRange());
         return true;
       }
       return false;
     }
   }
 

clang/lib/Sema/SemaConcept.cpp

return calculateConstraintSatisfaction(
           Sema::InstantiatingTemplate Inst(S, AtomicExpr->getBeginLoc(),
               Sema::InstantiatingTemplate::ConstraintSubstitution{},
               const_cast<NamedDecl *>(Template), Info,
               AtomicExpr->getSourceRange());
           if (Inst.isInvalid())
             return ExprError();
           // We do not want error diagnostics escaping here.
           Sema::SFINAETrap Trap(S);
-          SubstitutedExpression = S.SubstExpr(const_cast<Expr *>(AtomicExpr),
-                                              MLTAL);
+          SubstitutedExpression =
+              S.SubstExpr(const_cast<Expr *>(AtomicExpr), MLTAL,
+                          /*EarlySubstitution=*/false);
           // Substitution might have stripped off a contextual conversion to
           // bool if this is the operand of an '&&' or '||'. For example, we
           // might lose an lvalue-to-rvalue conversion here. If so, put it back
           // before we try to evaluate.
           if (!SubstitutedExpression.isInvalid())
             SubstitutedExpression =
                 S.PerformContextuallyConvertToBool(SubstitutedExpression.get());
           if (SubstitutedExpression.isInvalid() || Trap.hasErrorOccurred()) {
if (Decl->isTemplateInstantiation()) {
     InstantiatingTemplate Inst(*this, Decl->getPointOfInstantiation(),
         InstantiatingTemplate::ConstraintsCheck{}, Decl->getPrimaryTemplate(),
         TemplateArgs, SourceRange());
     if (Inst.isInvalid())
       return true;
     MultiLevelTemplateArgumentList MLTAL(
         *Decl->getTemplateSpecializationArgs());
     if (addInstantiatedParametersToScope(
-            Decl, Decl->getPrimaryTemplate()->getTemplatedDecl(), Scope, MLTAL))
+            Decl, Decl->getPrimaryTemplate()->getTemplatedDecl(), Scope, MLTAL,
+            /*EarlySubstitution=*/false))
       return true;
   }
   Qualifiers ThisQuals;
   CXXRecordDecl *Record = nullptr;
   if (auto *Method = dyn_cast<CXXMethodDecl>(Decl)) {
     ThisQuals = Method->getMethodQualifiers();
     Record = Method->getParent();
   }
for (unsigned I = 0, J = 0, C = TemplateParams->size(); I != C; ++I)
                 ArgsAsWritten->arguments()[I].getLocation() :
                 SourceLocation()));
   }
   Sema::InstantiatingTemplate Inst(
       S, ArgsAsWritten->arguments().front().getSourceRange().getBegin(),
       Sema::InstantiatingTemplate::ParameterMappingSubstitution{}, Concept,
       SourceRange(ArgsAsWritten->arguments()[0].getSourceRange().getBegin(),
                   ArgsAsWritten->arguments().back().getSourceRange().getEnd()));
-  if (S.SubstTemplateArguments(*Atomic.ParameterMapping, MLTAL, SubstArgs))
+  if (S.SubstTemplateArguments(*Atomic.ParameterMapping, MLTAL,
+                               /*EarlySubstitution=*/false, SubstArgs))
     return true;
   Atomic.ParameterMapping.emplace(
         MutableArrayRef<TemplateArgumentLoc>(
             new (S.Context) TemplateArgumentLoc[SubstArgs.size()],
             SubstArgs.size()));
   std::copy(SubstArgs.arguments().begin(), SubstArgs.arguments().end(),
             N.getAtomicConstraint()->ParameterMapping->begin());
   return false;

clang/lib/Sema/SemaDeclCXX.cpp

CallingConv CC =
       ConvRT->getPointeeType()->castAs<FunctionType>()->getCallConv();
 
   CXXRecordDecl *Lambda = Conv->getParent();
   FunctionDecl *CallOp = Lambda->getLambdaCallOperator();
   FunctionDecl *Invoker = Lambda->getLambdaStaticInvoker(CC);
 
   if (auto *TemplateArgs = Conv->getTemplateSpecializationArgs()) {
     CallOp = InstantiateFunctionDeclaration(
-        CallOp->getDescribedFunctionTemplate(), TemplateArgs, CurrentLocation);
+        CallOp->getDescribedFunctionTemplate(), TemplateArgs,
+        /*EarlySubstitution=*/false, CurrentLocation);
     if (!CallOp)
       return;
 
     Invoker = InstantiateFunctionDeclaration(
-        Invoker->getDescribedFunctionTemplate(), TemplateArgs, CurrentLocation);
+        Invoker->getDescribedFunctionTemplate(), TemplateArgs,
+        /*EarlySubstitution=*/false, CurrentLocation);
     if (!Invoker)
       return;
   }
 
   if (CallOp->isInvalidDecl())
     return;
 
   // Mark the call operator referenced (and add to pending instantiations
for (auto L : Lookup) {
         Pattern = cast<FieldDecl>(L);
         break;
       }
     }
     assert(Pattern && "We must have set the Pattern!");
 
     if (!Pattern->hasInClassInitializer() ||
         InstantiateInClassInitializer(Loc, Field, Pattern,
-                                      getTemplateInstantiationArgs(Field))) {
+                                      getTemplateInstantiationArgs(Field),
+                                      /*EarlySubstitution=*/false)) {
       // Don't diagnose this again.
       Field->setInvalidDecl();
       return ExprError();
     }
     return CXXDefaultInitExpr::Create(Context, Loc, Field, CurContext);
   }
 
   // DR1351:

clang/lib/Sema/SemaExprCXX.cpp

else if (ReturnTypeRequirement.isTypeConstraint()) {
     Args.push_back(TemplateArgument(MatchedType));
     TemplateArgumentList TAL(TemplateArgumentList::OnStack, Args);
     MultiLevelTemplateArgumentList MLTAL(TAL);
     for (unsigned I = 0; I < TPL->getDepth(); ++I)
       MLTAL.addOuterRetainedLevel();
     Expr *IDC =
         cast<TemplateTypeParmDecl>(TPL->getParam(0))->getTypeConstraint()
             ->getImmediatelyDeclaredConstraint();
-    ExprResult Constraint = SubstExpr(IDC, MLTAL);
+    ExprResult Constraint = SubstExpr(IDC, MLTAL, /*EarlySubstitution=*/false);
     assert(!Constraint.isInvalid() &&
            "Substitution cannot fail as it is simply putting a type template "
            "argument into a concept specialization expression's parameter.");
 
     SubstitutedConstraintExpr =
         cast<ConceptSpecializationExpr>(Constraint.get());
     if (!SubstitutedConstraintExpr->isSatisfied())
       Status = concepts::ExprRequirement::SS_ConstraintsNotSatisfied;

clang/lib/Sema/SemaTemplate.cpp

if (FTD) {
 
       // Later template parameters could refer to earlier ones, so build up
       // a list of substituted template arguments as we go.
       for (NamedDecl *Param : *InnerParams) {
         MultiLevelTemplateArgumentList Args;
         Args.setKind(TemplateSubstitutionKind::Rewrite);
         Args.addOuterTemplateArguments(SubstArgs);
         Args.addOuterRetainedLevel();
-        NamedDecl *NewParam = transformTemplateParameter(Param, Args);
+        NamedDecl *NewParam = transformTemplateParameter(
+            Param, Args, /*EarlySubstitution=*/false);
         if (!NewParam)
           return nullptr;
         AllParams.push_back(NewParam);
         SubstArgs.push_back(SemaRef.Context.getCanonicalTemplateArgument(
             SemaRef.Context.getInjectedTemplateArg(NewParam)));
       }
 
       // Substitute new template parameters into requires-clause if present.
       Expr *RequiresClause = nullptr;
       if (Expr *InnerRC = InnerParams->getRequiresClause()) {
         MultiLevelTemplateArgumentList Args;
         Args.setKind(TemplateSubstitutionKind::Rewrite);
         Args.addOuterTemplateArguments(SubstArgs);
         Args.addOuterRetainedLevel();
-        ExprResult E = SemaRef.SubstExpr(InnerRC, Args);
+        ExprResult E =
+            SemaRef.SubstExpr(InnerRC, Args, /*EarlySubstitution=*/false);
         if (E.isInvalid())
           return nullptr;
         RequiresClause = E.getAs<Expr>();
       }
 
       TemplateParams = TemplateParameterList::Create(
           SemaRef.Context, InnerParams->getTemplateLoc(),
           InnerParams->getLAngleLoc(), AllParams, InnerParams->getRAngleLoc(),
NamedDecl *transformConstructor(FunctionTemplateDecl *FTD,
 
     // Transform the type of the function, adjusting the return type and
     // replacing references to the old parameters with references to the
     // new ones.
     TypeLocBuilder TLB;
     SmallVector<ParmVarDecl*, 8> Params;
     SmallVector<TypedefNameDecl *, 4> MaterializedTypedefs;
     QualType NewType = transformFunctionProtoType(TLB, FPTL, Params, Args,
+                                                  /*EarlySubstitution=*/false,
                                                   MaterializedTypedefs);
     if (NewType.isNull())
       return nullptr;
     TypeSourceInfo *NewTInfo = TLB.getTypeSourceInfo(SemaRef.Context, NewType);
 
     return buildDeductionGuide(TemplateParams, CD, CD->getExplicitSpecifier(),
                                NewTInfo, CD->getBeginLoc(), CD->getLocation(),
                                CD->getEndLoc(), MaterializedTypedefs);
return buildDeductionGuide(Template->getTemplateParameters(), nullptr,
                                ExplicitSpecifier(), TSI, Loc, Loc, Loc);
   }
 
 private:
   /// Transform a constructor template parameter into a deduction guide template
   /// parameter, rebuilding any internal references to earlier parameters and
   /// renumbering as we go.
   NamedDecl *transformTemplateParameter(NamedDecl *TemplateParam,
-                                        MultiLevelTemplateArgumentList &Args) {
+                                        MultiLevelTemplateArgumentList &Args,
+                                        bool EarlySubstitution) {
     if (auto *TTP = dyn_cast<TemplateTypeParmDecl>(TemplateParam)) {
       // TemplateTypeParmDecl's index cannot be changed after creation, so
       // substitute it directly.
       auto *NewTTP = TemplateTypeParmDecl::Create(
           SemaRef.Context, DC, TTP->getBeginLoc(), TTP->getLocation(),
           /*Depth*/ 0, Depth1IndexAdjustment + TTP->getIndex(),
           TTP->getIdentifier(), TTP->wasDeclaredWithTypename(),
           TTP->isParameterPack(), TTP->hasTypeConstraint(),
           TTP->isExpandedParameterPack() ?
           llvm::Optional<unsigned>(TTP->getNumExpansionParameters()) : None);
       if (const auto *TC = TTP->getTypeConstraint())
-        SemaRef.SubstTypeConstraint(NewTTP, TC, Args);
+        SemaRef.SubstTypeConstraint(NewTTP, TC, Args, EarlySubstitution);
       if (TTP->hasDefaultArgument()) {
-        TypeSourceInfo *InstantiatedDefaultArg =
-            SemaRef.SubstType(TTP->getDefaultArgumentInfo(), Args,
-                              TTP->getDefaultArgumentLoc(), TTP->getDeclName());
+        TypeSourceInfo *InstantiatedDefaultArg = SemaRef.SubstType(
+            TTP->getDefaultArgumentInfo(), Args, EarlySubstitution,
+            TTP->getDefaultArgumentLoc(), TTP->getDeclName(),
+            /*AllowDeducedTST=*/false);
         if (InstantiatedDefaultArg)
           NewTTP->setDefaultArgument(InstantiatedDefaultArg);
       }
       SemaRef.CurrentInstantiationScope->InstantiatedLocal(TemplateParam,
                                                            NewTTP);
       return NewTTP;
     }
 
     if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(TemplateParam))
-      return transformTemplateParameterImpl(TTP, Args);
+      return transformTemplateParameterImpl(TTP, Args, EarlySubstitution);
 
     return transformTemplateParameterImpl(
-        cast<NonTypeTemplateParmDecl>(TemplateParam), Args);
+        cast<NonTypeTemplateParmDecl>(TemplateParam), Args, EarlySubstitution);
   }
-  template<typename TemplateParmDecl>
+  template <typename TemplateParmDecl>
   TemplateParmDecl *
   transformTemplateParameterImpl(TemplateParmDecl *OldParam,
-                                 MultiLevelTemplateArgumentList &Args) {
+                                 MultiLevelTemplateArgumentList &Args,
+                                 bool EarlySubstitution) {
     // Ask the template instantiator to do the heavy lifting for us, then adjust
     // the index of the parameter once it's done.
-    auto *NewParam =
-        cast<TemplateParmDecl>(SemaRef.SubstDecl(OldParam, DC, Args));
+    auto *NewParam = cast<TemplateParmDecl>(
+        SemaRef.SubstDecl(OldParam, DC, Args, EarlySubstitution));
     assert(NewParam->getDepth() == 0 && "unexpected template param depth");
     NewParam->setPosition(NewParam->getPosition() + Depth1IndexAdjustment);
     return NewParam;
   }
 
   QualType transformFunctionProtoType(
       TypeLocBuilder &TLB, FunctionProtoTypeLoc TL,
       SmallVectorImpl<ParmVarDecl *> &Params,
-      MultiLevelTemplateArgumentList &Args,
+      MultiLevelTemplateArgumentList &Args, bool EarlySubstitution,
       SmallVectorImpl<TypedefNameDecl *> &MaterializedTypedefs) {
     SmallVector<QualType, 4> ParamTypes;
     const FunctionProtoType *T = TL.getTypePtr();
 
     //    -- The types of the function parameters are those of the constructor.
     for (auto *OldParam : TL.getParams()) {
-      ParmVarDecl *NewParam =
-          transformFunctionTypeParam(OldParam, Args, MaterializedTypedefs);
+      ParmVarDecl *NewParam = transformFunctionTypeParam(
+          OldParam, Args, EarlySubstitution, MaterializedTypedefs);
       if (!NewParam)
         return QualType();
       ParamTypes.push_back(NewParam->getType());
       Params.push_back(NewParam);
     }
 
     //    -- The return type is the class template specialization designated by
     //       the template-name and template arguments corresponding to the
QualType transformFunctionProtoType(
     for (unsigned I = 0, E = NewTL.getNumParams(); I != E; ++I)
       NewTL.setParam(I, Params[I]);
 
     return Result;
   }
 
   ParmVarDecl *transformFunctionTypeParam(
       ParmVarDecl *OldParam, MultiLevelTemplateArgumentList &Args,
+      bool EarlySubstitution,
       llvm::SmallVectorImpl<TypedefNameDecl *> &MaterializedTypedefs) {
     TypeSourceInfo *OldDI = OldParam->getTypeSourceInfo();
     TypeSourceInfo *NewDI;
     if (auto PackTL = OldDI->getTypeLoc().getAs<PackExpansionTypeLoc>()) {
       // Expand out the one and only element in each inner pack.
       Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, 0);
       NewDI =
-          SemaRef.SubstType(PackTL.getPatternLoc(), Args,
+          SemaRef.SubstType(PackTL.getPatternLoc(), Args, EarlySubstitution,
                             OldParam->getLocation(), OldParam->getDeclName());
       if (!NewDI) return nullptr;
       NewDI =
           SemaRef.CheckPackExpansion(NewDI, PackTL.getEllipsisLoc(),
                                      PackTL.getTypePtr()->getNumExpansions());
     } else
-      NewDI = SemaRef.SubstType(OldDI, Args, OldParam->getLocation(),
-                                OldParam->getDeclName());
+      NewDI =
+          SemaRef.SubstType(OldDI, Args, EarlySubstitution,
+                            OldParam->getLocation(), OldParam->getDeclName(),
+                            /*AllowDeducedTST=*/false);
     if (!NewDI)
       return nullptr;
 
     // Extract the type. This (for instance) replaces references to typedef
     // members of the current instantiations with the definitions of those
     // typedefs, avoiding triggering instantiation of the deduced type during
     // deduction.
     NewDI = ExtractTypeForDeductionGuide(SemaRef, MaterializedTypedefs)
if (TypeAliasTemplateDecl *AliasTemplate =
     TemplateArgLists.addOuterRetainedLevels(
         AliasTemplate->getTemplateParameters()->getDepth());
 
     LocalInstantiationScope Scope(*this);
     InstantiatingTemplate Inst(*this, TemplateLoc, Template);
     if (Inst.isInvalid())
       return QualType();
 
-    CanonType = SubstType(Pattern->getUnderlyingType(),
-                          TemplateArgLists, AliasTemplate->getLocation(),
-                          AliasTemplate->getDeclName());
+    CanonType =
+        SubstType(Pattern->getUnderlyingType(), TemplateArgLists,
+                  /*EarlySubstitution=*/false, AliasTemplate->getLocation(),
     if (CanonType.isNull()) {
       // If this was enable_if and we failed to find the nested type
       // within enable_if in a SFINAE context, dig out the specific
       // enable_if condition that failed and present that instead.
       if (isEnableIfAliasTemplate(AliasTemplate)) {
         if (auto DeductionInfo = isSFINAEContext()) {
           if (*DeductionInfo &&
               (*DeductionInfo)->hasSFINAEDiagnostic() &&
if (TypeAliasTemplateDecl *AliasTemplate =
     }
 
     if (Decl->getSpecializationKind() == TSK_Undeclared &&
         ClassTemplate->getTemplatedDecl()->hasAttrs()) {
       InstantiatingTemplate Inst(*this, TemplateLoc, Decl);
       if (!Inst.isInvalid()) {
         MultiLevelTemplateArgumentList TemplateArgLists;
         TemplateArgLists.addOuterTemplateArguments(Converted);
-        InstantiateAttrsForDecl(TemplateArgLists,
-                                ClassTemplate->getTemplatedDecl(), Decl);
+        InstantiateAttrsForDecl(TemplateArgLists, /*EarlySubstitution=*/false,
+                                ClassTemplate->getTemplatedDecl(), Decl,
+                                /*LateAttrs=*/nullptr,
+                                /*OuterMostScope=*/nullptr);
       }
     }
 
     // Diagnose uses of this specialization.
     (void)DiagnoseUseOfDecl(Decl, TemplateLoc);
 
     CanonType = Context.getTypeDeclType(Decl);
     assert(isa<RecordType>(CanonType) &&
Sema::InstantiatingTemplate Inst(SemaRef, TemplateLoc,
                                      Param, Template, Converted,
                                      SourceRange(TemplateLoc, RAngleLoc));
     if (Inst.isInvalid())
       return nullptr;
 
     TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
 
     // Only substitute for the innermost template argument list.
+    // FIXME: Use EarlySubstitution=true
     MultiLevelTemplateArgumentList TemplateArgLists;
     TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
     for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
       TemplateArgLists.addOuterTemplateArguments(None);
 
     bool ForLambdaCallOperator = false;
     if (const auto *Rec = dyn_cast<CXXRecordDecl>(Template->getDeclContext()))
       ForLambdaCallOperator = Rec->isLambda();
     Sema::ContextRAII SavedContext(SemaRef, Template->getDeclContext(),
                                    !ForLambdaCallOperator);
-    ArgType =
-        SemaRef.SubstType(ArgType, TemplateArgLists,
-                          Param->getDefaultArgumentLoc(), Param->getDeclName());
+    ArgType = SemaRef.SubstType(
+        ArgType, TemplateArgLists, /*EarlySubstitution=*/false,
+        Param->getDefaultArgumentLoc(), Param->getDeclName(),
+        /*AllowDeducedTST=*/false);
   }
 
   return ArgType;
 }
 
 /// Substitute template arguments into the default template argument for
 /// the given non-type template parameter.
 ///
SubstDefaultTemplateArgument(Sema &SemaRef,
   MultiLevelTemplateArgumentList TemplateArgLists;
   TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
   for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
     TemplateArgLists.addOuterTemplateArguments(None);
 
   Sema::ContextRAII SavedContext(SemaRef, Template->getDeclContext());
   EnterExpressionEvaluationContext ConstantEvaluated(
       SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
-  return SemaRef.SubstExpr(Param->getDefaultArgument(), TemplateArgLists);
+  return SemaRef.SubstExpr(Param->getDefaultArgument(), TemplateArgLists,
+                           /*EarlySubstitution=*/false);
 }
 
 /// Substitute template arguments into the default template argument for
 /// the given template template parameter.
 ///
 /// \param SemaRef the semantic analysis object for which we are performing
 /// the substitution.
 ///
SubstDefaultTemplateArgument(Sema &SemaRef,
   TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
   for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
     TemplateArgLists.addOuterTemplateArguments(None);
 
   Sema::ContextRAII SavedContext(SemaRef, Template->getDeclContext());
   // Substitute into the nested-name-specifier first,
   QualifierLoc = Param->getDefaultArgument().getTemplateQualifierLoc();
   if (QualifierLoc) {
-    QualifierLoc =
-        SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgLists);
+    QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(
+        QualifierLoc, TemplateArgLists, /*EarlySubstitution=*/false);
     if (!QualifierLoc)
       return TemplateName();
   }
 
   return SemaRef.SubstTemplateName(
-             QualifierLoc,
-             Param->getDefaultArgument().getArgument().getAsTemplate(),
-             Param->getDefaultArgument().getTemplateNameLoc(),
-             TemplateArgLists);
+      QualifierLoc, Param->getDefaultArgument().getArgument().getAsTemplate(),
+      Param->getDefaultArgument().getTemplateNameLoc(), TemplateArgLists,
+      /*EarlySubstitution=*/false);
 }
 
 /// If the given template parameter has a default template
 /// argument, substitute into that default template argument and
 /// return the corresponding template argument.
 TemplateArgumentLoc
 Sema::SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template,
                                               SourceLocation TemplateLoc,
if (NTTPType->isInstantiationDependentType() &&
                                         Converted);
 
       // If the parameter is a pack expansion, expand this slice of the pack.
       if (auto *PET = NTTPType->getAs<PackExpansionType>()) {
         Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this,
                                                            ArgumentPackIndex);
         NTTPType = SubstType(PET->getPattern(),
                              MultiLevelTemplateArgumentList(TemplateArgs),
-                             NTTP->getLocation(),
+                             /*EarlySubstitution=*/false, NTTP->getLocation(),
                              NTTP->getDeclName());
       } else {
-        NTTPType = SubstType(NTTPType,
-                             MultiLevelTemplateArgumentList(TemplateArgs),
-                             NTTP->getLocation(),
-                             NTTP->getDeclName());
+        NTTPType =
+            SubstType(NTTPType, MultiLevelTemplateArgumentList(TemplateArgs),
+                      /*EarlySubstitution=*/false, NTTP->getLocation(),
       }
 
       // If that worked, check the non-type template parameter type
       // for validity.
       if (!NTTPType.isNull())
         NTTPType = CheckNonTypeTemplateParameterType(NTTPType,
                                                      NTTP->getLocation());
       if (NTTPType.isNull())
// FIXME: Skip this if the parameters aren't instantiation-dependent.
     InstantiatingTemplate Inst(*this, TemplateLoc, Template,
                                TempParm, Converted,
                                SourceRange(TemplateLoc, RAngleLoc));
     if (Inst.isInvalid())
       return true;
 
     TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
     Params = SubstTemplateParams(Params, CurContext,
-                                 MultiLevelTemplateArgumentList(TemplateArgs));
+                                 MultiLevelTemplateArgumentList(TemplateArgs),
+                                 /*EarlySubstitution=*/false);
     if (!Params)
       return true;
   }
 
   // C++1z [temp.local]p1: (DR1004)
   //   When [the injected-class-name] is used [...] as a template-argument for
   //   a template template-parameter [...] it refers to the class template
   //   itself.
if (!Def) {
       Diag(TemplateLoc, diag::err_explicit_instantiation_undefined_member)
         << 0 << Record->getDeclName() << Record->getDeclContext();
       Diag(Pattern->getLocation(), diag::note_forward_declaration)
         << Pattern;
       return true;
     } else {
       if (InstantiateClass(NameLoc, Record, Def,
                            getTemplateInstantiationArgs(Record),
-                           TSK))
+                           /*EarlySubstitution=*/false, TSK,
+                           /*Complain=*/true))
         return true;
 
       RecordDef = cast_or_null<CXXRecordDecl>(Record->getDefinition());
       if (!RecordDef)
         return true;
     }
   }
 
   // Instantiate all of the members of the class.
   InstantiateClassMembers(NameLoc, RecordDef,
-                          getTemplateInstantiationArgs(Record), TSK);
+                          getTemplateInstantiationArgs(Record),
+                          /*EarlySubstitution=*/false, TSK);
 
   if (TSK == TSK_ExplicitInstantiationDefinition)
     MarkVTableUsed(NameLoc, RecordDef, true);
 
   // FIXME: We don't have any representation for explicit instantiations of
   // member classes. Such a representation is not needed for compilation, but it
   // should be available for clients that want to see all of the declarations in
   // the source code.

clang/lib/Sema/SemaTemplateDeduction.cpp

if (PackedArgsBuilder.empty()) {
       TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Output);
       MultiLevelTemplateArgumentList Args(TemplateArgs);
 
       if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
         Sema::InstantiatingTemplate Inst(S, Template->getLocation(), Template,
                                          NTTP, Output,
                                          Template->getSourceRange());
         if (Inst.isInvalid() ||
-            S.SubstType(NTTP->getType(), Args, NTTP->getLocation(),
-                        NTTP->getDeclName()).isNull())
+            S.SubstType(NTTP->getType(), Args,
+                        /*EarlySubstitution=*/false, NTTP->getLocation(),
+                        NTTP->getDeclName())
+                .isNull())
           return true;
       } else if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Param)) {
         Sema::InstantiatingTemplate Inst(S, Template->getLocation(), Template,
                                          TTP, Output,
                                          Template->getSourceRange());
-        if (Inst.isInvalid() || !S.SubstDecl(TTP, S.CurContext, Args))
+        if (Inst.isInvalid() || !S.SubstDecl(TTP, S.CurContext, Args,
+                                             /*EarlySubstitution=*/false))
           return true;
       }
       // For type parameters, no substitution is ever required.
     }
 
     // Create the resulting argument pack.
     Output.push_back(
         TemplateArgument::CreatePackCopy(S.Context, PackedArgsBuilder));
FinishTemplateArgumentDeduction(
   const ASTTemplateArgumentListInfo *PartialTemplArgInfo =
       Partial->getTemplateArgsAsWritten();
 
   TemplateArgumentListInfo InstArgs(PartialTemplArgInfo->LAngleLoc,
                                     PartialTemplArgInfo->RAngleLoc);
 
   if (S.SubstTemplateArguments(
           PartialTemplArgInfo->arguments(),
-          MultiLevelTemplateArgumentList(*DeducedArgumentList), InstArgs)) {
+          MultiLevelTemplateArgumentList(*DeducedArgumentList),
+          /*EarlySubstitution=*/false, InstArgs)) {
     unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx;
     if (ParamIdx >= Partial->getTemplateParameters()->size())
       ParamIdx = Partial->getTemplateParameters()->size() - 1;
 
     Decl *Param = const_cast<NamedDecl *>(
         Partial->getTemplateParameters()->getParam(ParamIdx));
     Info.Param = makeTemplateParameter(Param);
     Info.FirstArg = (*PartialTemplArgInfo)[ArgIdx].getArgument();
Sema::SubstituteExplicitTemplateArguments(
   // Instantiate the types of each of the function parameters given the
   // explicitly-specified template arguments. If the function has a trailing
   // return type, substitute it after the arguments to ensure we substitute
   // in lexical order.
   if (Proto->hasTrailingReturn()) {
     if (SubstParmTypes(Function->getLocation(), Function->parameters(),
                        Proto->getExtParameterInfosOrNull(),
                        MultiLevelTemplateArgumentList(*ExplicitArgumentList),
-                       ParamTypes, /*params*/ nullptr, ExtParamInfos))
+                       /*EarlySubstitution=*/false, ParamTypes,
+                       /*params*/ nullptr, ExtParamInfos))
       return TDK_SubstitutionFailure;
   }
 
   // Instantiate the return type.
   QualType ResultType;
   {
     // C++11 [expr.prim.general]p3:
     //   If a declaration declares a member function or member function
QualType ResultType;
     }
 
     CXXThisScopeRAII ThisScope(*this, ThisContext, ThisTypeQuals,
                                getLangOpts().CPlusPlus11);
 
     ResultType =
         SubstType(Proto->getReturnType(),
                   MultiLevelTemplateArgumentList(*ExplicitArgumentList),
-                  Function->getTypeSpecStartLoc(), Function->getDeclName());
+                  /*EarlySubstitution=*/false, Function->getTypeSpecStartLoc(),
+                  Function->getDeclName());
     if (ResultType.isNull() || Trap.hasErrorOccurred())
       return TDK_SubstitutionFailure;
     // CUDA: Kernel function must have 'void' return type.
     if (getLangOpts().CUDA)
       if (Function->hasAttr<CUDAGlobalAttr>() && !ResultType->isVoidType()) {
         Diag(Function->getLocation(), diag::err_kern_type_not_void_return)
             << Function->getType() << Function->getSourceRange();
         return TDK_SubstitutionFailure;
       }
   }
 
   // Instantiate the types of each of the function parameters given the
   // explicitly-specified template arguments if we didn't do so earlier.
   if (!Proto->hasTrailingReturn() &&
       SubstParmTypes(Function->getLocation(), Function->parameters(),
                      Proto->getExtParameterInfosOrNull(),
                      MultiLevelTemplateArgumentList(*ExplicitArgumentList),
-                     ParamTypes, /*params*/ nullptr, ExtParamInfos))
+                     /*EarlySubstitution=*/false, ParamTypes,
+                     /*params*/ nullptr, ExtParamInfos))
     return TDK_SubstitutionFailure;
 
   if (FunctionType) {
     auto EPI = Proto->getExtProtoInfo();
     EPI.ExtParameterInfos = ExtParamInfos.getPointerOrNull(ParamTypes.size());
 
     // In C++1z onwards, exception specifications are part of the function type,
     // so substitution into the type must also substitute into the exception
     // specification.
     SmallVector<QualType, 4> ExceptionStorage;
     if (getLangOpts().CPlusPlus17 &&
         SubstExceptionSpec(
             Function->getLocation(), EPI.ExceptionSpec, ExceptionStorage,
-            MultiLevelTemplateArgumentList(*ExplicitArgumentList)))
+            MultiLevelTemplateArgumentList(*ExplicitArgumentList),
+            /*EarlySubstitution=*/false))
       return TDK_SubstitutionFailure;
 
     *FunctionType = BuildFunctionType(ResultType, ParamTypes,
                                       Function->getLocation(),
                                       Function->getDeclName(),
                                       EPI);
     if (FunctionType->isNull() || Trap.hasErrorOccurred())
       return TDK_SubstitutionFailure;
Sema::TemplateDeductionResult Sema::FinishTemplateArgumentDeduction(
 
   // Substitute the deduced template arguments into the function template
   // declaration to produce the function template specialization.
   DeclContext *Owner = FunctionTemplate->getDeclContext();
   if (FunctionTemplate->getFriendObjectKind())
     Owner = FunctionTemplate->getLexicalDeclContext();
   MultiLevelTemplateArgumentList SubstArgs(*DeducedArgumentList);
   Specialization = cast_or_null<FunctionDecl>(
-      SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner, SubstArgs));
+      SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner, SubstArgs,
+                /*EarlySubstitution=*/false));
   if (!Specialization || Specialization->isInvalidDecl())
     return TDK_SubstitutionFailure;
 
   assert(Specialization->getPrimaryTemplate()->getCanonicalDecl() ==
          FunctionTemplate->getCanonicalDecl());
 
   // If the template argument list is owned by the function template
   // specialization, release it.
for (unsigned I = 0, N = OriginalCallArgs->size(); I != N; ++I) {
         // braced-init-list argument. Substitute back into P to find the
         // deduced A.
         QualType &CacheEntry =
             DeducedATypes[{ParamIdx, OriginalArg.OriginalParamType}];
         if (CacheEntry.isNull()) {
           ArgumentPackSubstitutionIndexRAII PackIndex(
               *this, getPackIndexForParam(*this, FunctionTemplate, SubstArgs,
                                           ParamIdx));
-          CacheEntry =
-              SubstType(OriginalArg.OriginalParamType, SubstArgs,
+          CacheEntry = SubstType(OriginalArg.OriginalParamType, SubstArgs,
+                                 /*EarlySubstitution=*/false,
                                  Specialization->getTypeSpecStartLoc(),
                                  Specialization->getDeclName());
         }
         DeducedA = CacheEntry;
       }
 
       if (auto TDK =
               CheckOriginalCallArgDeduction(*this, Info, OriginalArg, DeducedA))
         return TDK;
     }
bool Sema::DeduceReturnType(FunctionDecl *FD, SourceLocation Loc,
   // within the return type from the call operator's type.
   if (isLambdaConversionOperator(FD)) {
     CXXRecordDecl *Lambda = cast<CXXMethodDecl>(FD)->getParent();
     FunctionDecl *CallOp = Lambda->getLambdaCallOperator();
 
     // For a generic lambda, instantiate the call operator if needed.
     if (auto *Args = FD->getTemplateSpecializationArgs()) {
       CallOp = InstantiateFunctionDeclaration(
-          CallOp->getDescribedFunctionTemplate(), Args, Loc);
+          CallOp->getDescribedFunctionTemplate(), Args,
+          /*EarlySubstitution=*/false, Loc);
       if (!CallOp || CallOp->isInvalidDecl())
         return true;
 
       // We might need to deduce the return type by instantiating the definition
       // of the operator() function.
       if (CallOp->getReturnType()->isUndeducedType()) {
         runWithSufficientStackSpace(Loc, [&] {
           InstantiateFunctionDefinition(Loc, CallOp);

clang/lib/Sema/SemaTemplateInstantiate.cpp

 //===----------------------------------------------------------------------===/
 // Template Instantiation for Types
 //===----------------------------------------------------------------------===/
 namespace {
   class TemplateInstantiator : public TreeTransform<TemplateInstantiator> {
     const MultiLevelTemplateArgumentList &TemplateArgs;
     SourceLocation Loc;
     DeclarationName Entity;
+    bool EarlySubstitution;
 
   public:
     typedef TreeTransform<TemplateInstantiator> inherited;
 
     TemplateInstantiator(Sema &SemaRef,
                          const MultiLevelTemplateArgumentList &TemplateArgs,
-                         SourceLocation Loc,
-                         DeclarationName Entity)
+                         SourceLocation Loc, DeclarationName Entity,
+                         bool EarlySubstitution)
         : inherited(SemaRef), TemplateArgs(TemplateArgs), Loc(Loc),
-        Entity(Entity) { }
+          Entity(Entity), EarlySubstitution(EarlySubstitution) {}
 
     /// Determine whether the given type \p T has already been
     /// transformed.
     ///
     /// For the purposes of template instantiation, a type has already been
     /// transformed if it is NULL or if it is not dependent.
     bool AlreadyTransformed(QualType T);
 
void RememberPartiallySubstitutedPack(TemplateArgument Arg) {
       }
     }
 
     /// Transform the given declaration by instantiating a reference to
     /// this declaration.
     Decl *TransformDecl(SourceLocation Loc, Decl *D);
 
     void transformAttrs(Decl *Old, Decl *New) {
-      SemaRef.InstantiateAttrs(TemplateArgs, Old, New);
+      SemaRef.InstantiateAttrs(TemplateArgs, EarlySubstitution, Old, New,
+                               /*LateAttrs=*/nullptr,
+                               /*OuterMostScope=*/nullptr);
     }
 
     void transformedLocalDecl(Decl *Old, ArrayRef<Decl *> NewDecls) {
       if (Old->isParameterPack()) {
         SemaRef.CurrentInstantiationScope->MakeInstantiatedLocalArgPack(Old);
         for (auto *New : NewDecls)
           SemaRef.CurrentInstantiationScope->InstantiatedLocalPackArg(
               Old, cast<VarDecl>(New));
void transformedLocalDecl(Decl *Old, ArrayRef<Decl *> NewDecls) {
                                                   TSK_ImplicitInstantiation);
       }
 
       SemaRef.CurrentInstantiationScope->InstantiatedLocal(Old, New);
 
       // We recreated a local declaration, but not by instantiating it. There
       // may be pending dependent diagnostics to produce.
       if (auto *DC = dyn_cast<DeclContext>(Old))
-        SemaRef.PerformDependentDiagnostics(DC, TemplateArgs);
+        SemaRef.PerformDependentDiagnostics(DC, TemplateArgs,
+                                            EarlySubstitution);
     }
 
     /// Transform the definition of the given declaration by
     /// instantiating it.
     Decl *TransformDefinition(SourceLocation Loc, Decl *D);
 
     /// Transform the first qualifier within a scope by instantiating the
     /// declaration.
bool TransformRequiresExprRequirements(
       return false;
     }
 
     TemplateParameterList *TransformTemplateParameterList(
                               TemplateParameterList *OrigTPL)  {
       if (!OrigTPL || !OrigTPL->size()) return OrigTPL;
 
       DeclContext *Owner = OrigTPL->getParam(0)->getDeclContext();
-      TemplateDeclInstantiator  DeclInstantiator(getSema(),
-                        /* DeclContext *Owner */ Owner, TemplateArgs);
+      TemplateDeclInstantiator DeclInstantiator(
+          getSema(),
+          /* DeclContext *Owner */ Owner, TemplateArgs, EarlySubstitution);
       return DeclInstantiator.SubstTemplateParams(OrigTPL);
     }
 
     concepts::TypeRequirement *
     TransformTypeRequirement(concepts::TypeRequirement *Req);
     concepts::ExprRequirement *
     TransformExprRequirement(concepts::ExprRequirement *Req);
     concepts::NestedRequirement *
     TransformNestedRequirement(concepts::NestedRequirement *Req);
 
   private:
     ExprResult transformNonTypeTemplateParmRef(NonTypeTemplateParmDecl *parm,
                                                SourceLocation loc,
                                                TemplateArgument arg);
+
+    unsigned getNewDepth(unsigned Depth) const {
+      return Depth -
+             (EarlySubstitution ? 0 : TemplateArgs.getNumSubstitutedLevels());
+    }
   };
 }
 
 bool TemplateInstantiator::AlreadyTransformed(QualType T) {
   if (T.isNull())
     return true;
 
   if (T->isInstantiationDependentType() || T->isVariablyModifiedType())
     return false;
if (TTP->getDepth() < TemplateArgs.getNumLevels()) {
              "Wrong kind of template template argument");
       return Template.getAsTemplateDecl();
     }
 
     // Fall through to find the instantiated declaration for this template
     // template parameter.
   }
 
-  return SemaRef.FindInstantiatedDecl(Loc, cast<NamedDecl>(D), TemplateArgs);
+  return SemaRef.FindInstantiatedDecl(Loc, cast<NamedDecl>(D), TemplateArgs,
+                                      EarlySubstitution,
+                                      /*FindingInstantiatedContext=*/false);
 }
 
 Decl *TemplateInstantiator::TransformDefinition(SourceLocation Loc, Decl *D) {
-  Decl *Inst = getSema().SubstDecl(D, getSema().CurContext, TemplateArgs);
+  Decl *Inst = getSema().SubstDecl(D, getSema().CurContext, TemplateArgs,
+                                   EarlySubstitution);
   if (!Inst)
     return nullptr;
 
   getSema().CurrentInstantiationScope->InstantiatedLocal(D, Inst);
   return Inst;
 }
 
 NamedDecl *
TemplateInstantiator::TransformTemplateParmRefExpr(DeclRefExpr *E,
   if (NTTP->isParameterPack()) {
     assert(Arg.getKind() == TemplateArgument::Pack &&
            "Missing argument pack");
 
     if (getSema().ArgumentPackSubstitutionIndex == -1) {
       // We have an argument pack, but we can't select a particular argument
       // out of it yet. Therefore, we'll build an expression to hold on to that
       // argument pack.
-      QualType TargetType = SemaRef.SubstType(NTTP->getType(), TemplateArgs,
-                                              E->getLocation(),
-                                              NTTP->getDeclName());
+      QualType TargetType =
+          SemaRef.SubstType(NTTP->getType(), TemplateArgs, EarlySubstitution,
+                            E->getLocation(), NTTP->getDeclName());
       if (TargetType.isNull())
         return ExprError();
 
       QualType ExprType = TargetType.getNonLValueExprType(SemaRef.Context);
       if (TargetType->isRecordType())
         ExprType.addConst();
 
       return new (SemaRef.Context) SubstNonTypeTemplateParmPackExpr(
ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
   auto SubstParamType = [&] {
     QualType T;
     if (parm->isExpandedParameterPack())
       T = parm->getExpansionType(SemaRef.ArgumentPackSubstitutionIndex);
     else
       T = parm->getType();
     if (parm->isParameterPack() && isa<PackExpansionType>(T))
       T = cast<PackExpansionType>(T)->getPattern();
-    return SemaRef.SubstType(T, TemplateArgs, loc, parm->getDeclName());
+    return SemaRef.SubstType(T, TemplateArgs, EarlySubstitution, loc,
+                             parm->getDeclName());
   };
 
   bool refParam = false;
 
   // The template argument itself might be an expression, in which case we just
   // return that expression. This happens when substituting into an alias
   // template.
   if (arg.getKind() == TemplateArgument::Expression) {
ExprResult TemplateInstantiator::transformNonTypeTemplateParmRef(
   } else if (arg.getKind() == TemplateArgument::Declaration ||
              arg.getKind() == TemplateArgument::NullPtr) {
     ValueDecl *VD;
     if (arg.getKind() == TemplateArgument::Declaration) {
       VD = arg.getAsDecl();
 
       // Find the instantiation of the template argument.  This is
       // required for nested templates.
-      VD = cast_or_null<ValueDecl>(
-             getSema().FindInstantiatedDecl(loc, VD, TemplateArgs));
+      VD = cast_or_null<ValueDecl>(getSema().FindInstantiatedDecl(
+          loc, VD, TemplateArgs, EarlySubstitution,
+          /*FindingInstantiatedContext=*/false));
       if (!VD)
         return ExprError();
     } else {
       // Propagate NULL template argument.
       VD = nullptr;
     }
 
     QualType paramType = VD ? arg.getParamTypeForDecl() : arg.getNullPtrType();
return inherited::TransformFunctionProtoType(
       TLB, TL, ThisContext, ThisTypeQuals, TransformExceptionSpec);
 }
 
 ParmVarDecl *
 TemplateInstantiator::TransformFunctionTypeParam(ParmVarDecl *OldParm,
                                                  int indexAdjustment,
                                                Optional<unsigned> NumExpansions,
                                                  bool ExpectParameterPack) {
-  auto NewParm =
-      SemaRef.SubstParmVarDecl(OldParm, TemplateArgs, indexAdjustment,
+  auto NewParm = SemaRef.SubstParmVarDecl(OldParm, TemplateArgs,
+                                          EarlySubstitution, indexAdjustment,
                                           NumExpansions, ExpectParameterPack);
   if (NewParm && SemaRef.getLangOpts().OpenCL)
     SemaRef.deduceOpenCLAddressSpace(NewParm);
   return NewParm;
 }
 
 QualType
 TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
                                                 TemplateTypeParmTypeLoc TL) {
TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
   // template we are instantiating). Create a new template type
   // parameter with the template "level" reduced by one.
   TemplateTypeParmDecl *NewTTPDecl = nullptr;
   if (TemplateTypeParmDecl *OldTTPDecl = T->getDecl())
     NewTTPDecl = cast_or_null<TemplateTypeParmDecl>(
                                   TransformDecl(TL.getNameLoc(), OldTTPDecl));
 
   QualType Result = getSema().Context.getTemplateTypeParmType(
-      T->getDepth() - TemplateArgs.getNumSubstitutedLevels(), T->getIndex(),
-      T->isParameterPack(), NewTTPDecl);
+      getNewDepth(T->getDepth()), T->getIndex(), T->isParameterPack(),
+      NewTTPDecl);
   TemplateTypeParmTypeLoc NewTL = TLB.push<TemplateTypeParmTypeLoc>(Result);
   NewTL.setNameLoc(TL.getNameLoc());
   return Result;
 }
 
 QualType
 TemplateInstantiator::TransformSubstTemplateTypeParmPackType(
                                                             TypeLocBuilder &TLB,

 ///
 /// \param AllowDeducedTST Whether a DeducedTemplateSpecializationType is
 /// acceptable as the top level type of the result.
 ///
 /// \returns If the instantiation succeeds, the instantiated
 /// type. Otherwise, produces diagnostics and returns a NULL type.
 TypeSourceInfo *Sema::SubstType(TypeSourceInfo *T,
                                 const MultiLevelTemplateArgumentList &Args,
-                                SourceLocation Loc,
-                                DeclarationName Entity,
-                                bool AllowDeducedTST) {
+                                bool EarlySubstitution, SourceLocation Loc,
+                                DeclarationName Entity, bool AllowDeducedTST) {
   assert(!CodeSynthesisContexts.empty() &&
          "Cannot perform an instantiation without some context on the "
          "instantiation stack");
 
   if (!T->getType()->isInstantiationDependentType() &&
       !T->getType()->isVariablyModifiedType())
     return T;
 
-  TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
+  TemplateInstantiator Instantiator(*this, Args, Loc, Entity,
+                                    EarlySubstitution);
   return AllowDeducedTST ? Instantiator.TransformTypeWithDeducedTST(T)
                          : Instantiator.TransformType(T);
 }
 
 TypeSourceInfo *Sema::SubstType(TypeLoc TL,
                                 const MultiLevelTemplateArgumentList &Args,
-                                SourceLocation Loc,
+                                bool EarlySubstitution, SourceLocation Loc,
                                 DeclarationName Entity) {
   assert(!CodeSynthesisContexts.empty() &&
          "Cannot perform an instantiation without some context on the "
          "instantiation stack");
 
   if (TL.getType().isNull())
     return nullptr;
 
   if (!TL.getType()->isInstantiationDependentType() &&
       !TL.getType()->isVariablyModifiedType()) {
     // FIXME: Make a copy of the TypeLoc data here, so that we can
     // return a new TypeSourceInfo. Inefficient!
     TypeLocBuilder TLB;
     TLB.pushFullCopy(TL);
     return TLB.getTypeSourceInfo(Context, TL.getType());
   }
 
-  TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
+  TemplateInstantiator Instantiator(*this, Args, Loc, Entity,
+                                    EarlySubstitution);
   TypeLocBuilder TLB;
   TLB.reserve(TL.getFullDataSize());
   QualType Result = Instantiator.TransformType(TLB, TL);
   if (Result.isNull())
     return nullptr;
 
   return TLB.getTypeSourceInfo(Context, Result);
 }
 
 /// Deprecated form of the above.
 QualType Sema::SubstType(QualType T,
                          const MultiLevelTemplateArgumentList &TemplateArgs,
-                         SourceLocation Loc, DeclarationName Entity) {
+                         bool EarlySubstitution, SourceLocation Loc,
+                         DeclarationName Entity) {
   assert(!CodeSynthesisContexts.empty() &&
          "Cannot perform an instantiation without some context on the "
          "instantiation stack");
 
   // If T is not a dependent type or a variably-modified type, there
   // is nothing to do.
   if (!T->isInstantiationDependentType() && !T->isVariablyModifiedType())
     return T;
 
-  TemplateInstantiator Instantiator(*this, TemplateArgs, Loc, Entity);
+  TemplateInstantiator Instantiator(*this, TemplateArgs, Loc, Entity,
+                                    EarlySubstitution);
   return Instantiator.TransformType(T);
 }
 
 static bool NeedsInstantiationAsFunctionType(TypeSourceInfo *T) {
   if (T->getType()->isInstantiationDependentType() ||
       T->getType()->isVariablyModifiedType())
     return true;
 
static bool NeedsInstantiationAsFunctionType(TypeSourceInfo *T) {
 
   return false;
 }
 
 /// A form of SubstType intended specifically for instantiating the
 /// type of a FunctionDecl.  Its purpose is solely to force the
 /// instantiation of default-argument expressions and to avoid
 /// instantiating an exception-specification.
-TypeSourceInfo *Sema::SubstFunctionDeclType(TypeSourceInfo *T,
-                                const MultiLevelTemplateArgumentList &Args,
-                                SourceLocation Loc,
-                                DeclarationName Entity,
-                                CXXRecordDecl *ThisContext,
-                                Qualifiers ThisTypeQuals) {
+TypeSourceInfo *Sema::SubstFunctionDeclType(
+    TypeSourceInfo *T, const MultiLevelTemplateArgumentList &Args,
+    bool EarlySubstitution, SourceLocation Loc, DeclarationName Entity,
+    CXXRecordDecl *ThisContext, Qualifiers ThisTypeQuals) {
   assert(!CodeSynthesisContexts.empty() &&
          "Cannot perform an instantiation without some context on the "
          "instantiation stack");
 
   if (!NeedsInstantiationAsFunctionType(T))
     return T;
 
-  TemplateInstantiator Instantiator(*this, Args, Loc, Entity);
+  TemplateInstantiator Instantiator(*this, Args, Loc, Entity,
+                                    EarlySubstitution);
 
   TypeLocBuilder TLB;
 
   TypeLoc TL = T->getTypeLoc();
   TLB.reserve(TL.getFullDataSize());
 
   QualType Result;
 
   if (FunctionProtoTypeLoc Proto =
           TL.IgnoreParens().getAs<FunctionProtoTypeLoc>()) {
     // Instantiate the type, other than its exception specification. The
     // exception specification is instantiated in InitFunctionInstantiation
     // once we've built the FunctionDecl.
     // FIXME: Set the exception specification to EST_Uninstantiated here,
     // instead of rebuilding the function type again later.
     Result = Instantiator.TransformFunctionProtoType(
         TLB, Proto, ThisContext, ThisTypeQuals,
-        [](FunctionProtoType::ExceptionSpecInfo &ESI,
-           bool &Changed) { return false; });
+        [](FunctionProtoType::ExceptionSpecInfo &ESI, bool &Changed) {
+          return false;
+        });
   } else {
     Result = Instantiator.TransformType(TLB, TL);
   }
   if (Result.isNull())
     return nullptr;
 
   return TLB.getTypeSourceInfo(Context, Result);
 }
 
 bool Sema::SubstExceptionSpec(SourceLocation Loc,
                               FunctionProtoType::ExceptionSpecInfo &ESI,
                               SmallVectorImpl<QualType> &ExceptionStorage,
-                              const MultiLevelTemplateArgumentList &Args) {
+                              const MultiLevelTemplateArgumentList &Args,
+                              bool EarlySubstitution) {
   assert(ESI.Type != EST_Uninstantiated);
 
   bool Changed = false;
-  TemplateInstantiator Instantiator(*this, Args, Loc, DeclarationName());
+  TemplateInstantiator Instantiator(*this, Args, Loc, DeclarationName(),
+                                    EarlySubstitution);
   return Instantiator.TransformExceptionSpec(Loc, ESI, ExceptionStorage,
                                              Changed);
 }
 
 void Sema::SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto,
-                              const MultiLevelTemplateArgumentList &Args) {
+                              const MultiLevelTemplateArgumentList &Args,
+                              bool EarlySubstitution) {
   FunctionProtoType::ExceptionSpecInfo ESI =
       Proto->getExtProtoInfo().ExceptionSpec;
 
   SmallVector<QualType, 4> ExceptionStorage;
   if (SubstExceptionSpec(New->getTypeSourceInfo()->getTypeLoc().getEndLoc(),
-                         ESI, ExceptionStorage, Args))
+                         ESI, ExceptionStorage, Args, EarlySubstitution))
     // On error, recover by dropping the exception specification.
     ESI.Type = EST_None;
 
   UpdateExceptionSpec(New, ESI);
 }
 
 namespace {
 
TemplateTypeParmDecl *VisitPackExpansionType(const PackExpansionType *T) {
       return Visit(T->getPattern());
     }
   };
 
 } // namespace
 
 bool Sema::SubstTypeConstraint(
     TemplateTypeParmDecl *Inst, const TypeConstraint *TC,
-    const MultiLevelTemplateArgumentList &TemplateArgs) {
+    const MultiLevelTemplateArgumentList &TemplateArgs,
+    bool EarlySubstitution) {
   const ASTTemplateArgumentListInfo *TemplArgInfo =
       TC->getTemplateArgsAsWritten();
   TemplateArgumentListInfo InstArgs;
 
   if (TemplArgInfo) {
     InstArgs.setLAngleLoc(TemplArgInfo->LAngleLoc);
     InstArgs.setRAngleLoc(TemplArgInfo->RAngleLoc);
     if (SubstTemplateArguments(TemplArgInfo->arguments(), TemplateArgs,
-                               InstArgs))
+                               EarlySubstitution, InstArgs))
       return true;
   }
   return AttachTypeConstraint(
       TC->getNestedNameSpecifierLoc(), TC->getConceptNameInfo(),
       TC->getNamedConcept(), &InstArgs, Inst,
       Inst->isParameterPack()
           ? cast<CXXFoldExpr>(TC->getImmediatelyDeclaredConstraint())
                 ->getEllipsisLoc()
           : SourceLocation());
 }
 
-ParmVarDecl *Sema::SubstParmVarDecl(ParmVarDecl *OldParm,
-                            const MultiLevelTemplateArgumentList &TemplateArgs,
-                                    int indexAdjustment,
-                                    Optional<unsigned> NumExpansions,
-                                    bool ExpectParameterPack) {
+ParmVarDecl *Sema::SubstParmVarDecl(
+    ParmVarDecl *OldParm, const MultiLevelTemplateArgumentList &TemplateArgs,
+    bool EarlySubstitution, int indexAdjustment,
+    Optional<unsigned> NumExpansions, bool ExpectParameterPack) {
   TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo();
   TypeSourceInfo *NewDI = nullptr;
 
   TypeLoc OldTL = OldDI->getTypeLoc();
   if (PackExpansionTypeLoc ExpansionTL = OldTL.getAs<PackExpansionTypeLoc>()) {
 
     // We have a function parameter pack. Substitute into the pattern of the
     // expansion.
-    NewDI = SubstType(ExpansionTL.getPatternLoc(), TemplateArgs,
-                      OldParm->getLocation(), OldParm->getDeclName());
+    NewDI =
+        SubstType(ExpansionTL.getPatternLoc(), TemplateArgs, EarlySubstitution,
     if (!NewDI)
       return nullptr;
 
     if (NewDI->getType()->containsUnexpandedParameterPack()) {
       // We still have unexpanded parameter packs, which means that
       // our function parameter is still a function parameter pack.
       // Therefore, make its type a pack expansion type.
       NewDI = CheckPackExpansion(NewDI, ExpansionTL.getEllipsisLoc(),
                                  NumExpansions);
     } else if (ExpectParameterPack) {
       // We expected to get a parameter pack but didn't (because the type
       // itself is not a pack expansion type), so complain. This can occur when
       // the substitution goes through an alias template that "loses" the
       // pack expansion.
       Diag(OldParm->getLocation(),
            diag::err_function_parameter_pack_without_parameter_packs)
         << NewDI->getType();
       return nullptr;
     }
   } else {
-    NewDI = SubstType(OldDI, TemplateArgs, OldParm->getLocation(),
-                      OldParm->getDeclName());
+    NewDI = SubstType(OldDI, TemplateArgs, EarlySubstitution,
+                      OldParm->getLocation(), OldParm->getDeclName(),
+                      /*AllowDeducedTST=*/false);
   }
 
   if (!NewDI)
     return nullptr;
 
   if (NewDI->getType()->isVoidType()) {
     Diag(OldParm->getLocation(), diag::err_param_with_void_type);
     return nullptr;
   }
 
   // In abbreviated templates, TemplateTypeParmDecls with possible
   // TypeConstraints are created when the parameter list is originally parsed.
   // The TypeConstraints can therefore reference other functions parameters in
   // the abbreviated function template, which is why we must instantiate them
   // here, when the instantiated versions of those referenced parameters are in
   // scope.
   if (TemplateTypeParmDecl *TTP =
           GetContainedInventedTypeParmVisitor().Visit(OldDI->getType())) {
     if (const TypeConstraint *TC = TTP->getTypeConstraint()) {
-      auto *Inst = cast_or_null<TemplateTypeParmDecl>(
-          FindInstantiatedDecl(TTP->getLocation(), TTP, TemplateArgs));
+      auto *Inst = cast_or_null<TemplateTypeParmDecl>(FindInstantiatedDecl(
+          TTP->getLocation(), TTP, TemplateArgs, EarlySubstitution,
+          /*FindingInstantiatedContext=*/false));
       // We will first get here when instantiating the abbreviated function
       // template's described function, but we might also get here later.
       // Make sure we do not instantiate the TypeConstraint more than once.
       if (Inst && !Inst->getTypeConstraint()) {
         // TODO: Concepts: do not instantiate the constraint (delayed constraint
         // substitution)
-        if (SubstTypeConstraint(Inst, TC, TemplateArgs))
+        if (SubstTypeConstraint(Inst, TC, TemplateArgs, EarlySubstitution))
           return nullptr;
       }
     }
   }
 
   ParmVarDecl *NewParm = CheckParameter(Context.getTranslationUnitDecl(),
                                         OldParm->getInnerLocStart(),
                                         OldParm->getLocation(),
if (OldParm->hasUninstantiatedDefaultArg()) {
     UnparsedDefaultArgInstantiations[OldParm].push_back(NewParm);
   } else if (Expr *Arg = OldParm->getDefaultArg()) {
     FunctionDecl *OwningFunc = cast<FunctionDecl>(OldParm->getDeclContext());
     if (OwningFunc->isInLocalScopeForInstantiation()) {
       // Instantiate default arguments for methods of local classes (DR1484)
       // and non-defining declarations.
       Sema::ContextRAII SavedContext(*this, OwningFunc);
       LocalInstantiationScope Local(*this, true);
-      ExprResult NewArg = SubstExpr(Arg, TemplateArgs);
+      ExprResult NewArg = SubstExpr(Arg, TemplateArgs, EarlySubstitution);
       if (NewArg.isUsable()) {
         // It would be nice if we still had this.
         SourceLocation EqualLoc = NewArg.get()->getBeginLoc();
         ExprResult Result =
             ConvertParamDefaultArgument(NewParm, NewArg.get(), EqualLoc);
         if (Result.isInvalid())
           return nullptr;
 
ParmVarDecl *Sema::SubstParmVarDecl(
 
   // FIXME: OldParm may come from a FunctionProtoType, in which case CurContext
   // can be anything, is this right ?
   NewParm->setDeclContext(CurContext);
 
   NewParm->setScopeInfo(OldParm->getFunctionScopeDepth(),
                         OldParm->getFunctionScopeIndex() + indexAdjustment);
 
-  InstantiateAttrs(TemplateArgs, OldParm, NewParm);
+  InstantiateAttrs(TemplateArgs, EarlySubstitution, OldParm, NewParm,
+                   /*LateAttrs=*/nullptr,
+                   /*OuterMostScope=*/nullptr);
 
   return NewParm;
 }
 
 /// Substitute the given template arguments into the given set of
 /// parameters, producing the set of parameter types that would be generated
 /// from such a substitution.
 bool Sema::SubstParmTypes(
     SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
     const FunctionProtoType::ExtParameterInfo *ExtParamInfos,
-    const MultiLevelTemplateArgumentList &TemplateArgs,
+    const MultiLevelTemplateArgumentList &TemplateArgs, bool EarlySubstitution,
     SmallVectorImpl<QualType> &ParamTypes,
     SmallVectorImpl<ParmVarDecl *> *OutParams,
     ExtParameterInfoBuilder &ParamInfos) {
   assert(!CodeSynthesisContexts.empty() &&
          "Cannot perform an instantiation without some context on the "
          "instantiation stack");
 
-  TemplateInstantiator Instantiator(*this, TemplateArgs, Loc,
-                                    DeclarationName());
+  TemplateInstantiator Instantiator(*this, TemplateArgs, Loc, DeclarationName(),
+                                    EarlySubstitution);
   return Instantiator.TransformFunctionTypeParams(
       Loc, Params, nullptr, ExtParamInfos, ParamTypes, OutParams, ParamInfos);
 }
 
 /// Perform substitution on the base class specifiers of the
 /// given class template specialization.
 ///
 /// Produces a diagnostic and returns true on error, returns false and
 /// attaches the instantiated base classes to the class template
 /// specialization if successful.
-bool
-Sema::SubstBaseSpecifiers(CXXRecordDecl *Instantiation,
-                          CXXRecordDecl *Pattern,
-                          const MultiLevelTemplateArgumentList &TemplateArgs) {
+bool Sema::SubstBaseSpecifiers(
+    CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
+    const MultiLevelTemplateArgumentList &TemplateArgs,
+    bool EarlySubstitution) {
   bool Invalid = false;
   SmallVector<CXXBaseSpecifier*, 4> InstantiatedBases;
   for (const auto &Base : Pattern->bases()) {
     if (!Base.getType()->isDependentType()) {
       if (const CXXRecordDecl *RD = Base.getType()->getAsCXXRecordDecl()) {
         if (RD->isInvalidDecl())
           Instantiation->setInvalidDecl();
       }
if (Base.isPackExpansion()) {
         continue;
       }
 
       // If we should expand this pack expansion now, do so.
       if (ShouldExpand) {
         for (unsigned I = 0; I != *NumExpansions; ++I) {
             Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I);
 
-          TypeSourceInfo *BaseTypeLoc = SubstType(Base.getTypeSourceInfo(),
-                                                  TemplateArgs,
-                                              Base.getSourceRange().getBegin(),
-                                                  DeclarationName());
+            TypeSourceInfo *BaseTypeLoc = SubstType(
+                Base.getTypeSourceInfo(), TemplateArgs, EarlySubstitution,
+                Base.getSourceRange().getBegin(), DeclarationName(),
+                /*AllowDeducedTST=*/false);
             if (!BaseTypeLoc) {
               Invalid = true;
               continue;
             }
 
           if (CXXBaseSpecifier *InstantiatedBase
                 = CheckBaseSpecifier(Instantiation,
                                      Base.getSourceRange(),
                                      Base.isVirtual(),
                                      Base.getAccessSpecifierAsWritten(),
                                      BaseTypeLoc,
                                      SourceLocation()))
             InstantiatedBases.push_back(InstantiatedBase);
           else
             Invalid = true;
         }
 
         continue;
       }
 
       // The resulting base specifier will (still) be a pack expansion.
       EllipsisLoc = Base.getEllipsisLoc();
       Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, -1);
-      BaseTypeLoc = SubstType(Base.getTypeSourceInfo(),
-                              TemplateArgs,
-                              Base.getSourceRange().getBegin(),
-                              DeclarationName());
-    } else {
-      BaseTypeLoc = SubstType(Base.getTypeSourceInfo(),
-                              TemplateArgs,
-                              Base.getSourceRange().getBegin(),
-                              DeclarationName());
+      BaseTypeLoc =
+          SubstType(Base.getTypeSourceInfo(), TemplateArgs, EarlySubstitution,
+                    Base.getSourceRange().getBegin(), DeclarationName(),
+                    /*AllowDeducedTST=*/false);
+    } else {
+      BaseTypeLoc =
+          SubstType(Base.getTypeSourceInfo(), TemplateArgs, EarlySubstitution,
+                    Base.getSourceRange().getBegin(), DeclarationName(),
+                    /*AllowDeducedTST=*/false);
     }
 
     if (!BaseTypeLoc) {
       Invalid = true;
       continue;
     }
 
     if (CXXBaseSpecifier *InstantiatedBase
if (!Invalid && AttachBaseSpecifiers(Instantiation, InstantiatedBases))
     Invalid = true;
 
   return Invalid;
 }
 
 // Defined via #include from SemaTemplateInstantiateDecl.cpp
 namespace clang {
   namespace sema {
-    Attr *instantiateTemplateAttribute(const Attr *At, ASTContext &C, Sema &S,
-                            const MultiLevelTemplateArgumentList &TemplateArgs);
-    Attr *instantiateTemplateAttributeForDecl(
-        const Attr *At, ASTContext &C, Sema &S,
-        const MultiLevelTemplateArgumentList &TemplateArgs);
+  Attr *instantiateTemplateAttribute(
+      const Attr *At, ASTContext &C, Sema &S,
+      const MultiLevelTemplateArgumentList &TemplateArgs,
+      bool EarlySubstitution);
+      const MultiLevelTemplateArgumentList &TemplateArgs,
+      bool EarlySubstitution);
   }
 }
 
 /// Instantiate the definition of a class from a given pattern.
 ///
 /// \param PointOfInstantiation The point of instantiation within the
 /// source code.
 ///

 /// the pattern.
 ///
 /// \param TSK the kind of implicit or explicit instantiation to perform.
 ///
 /// \param Complain whether to complain if the class cannot be instantiated due
 /// to the lack of a definition.
 ///
 /// \returns true if an error occurred, false otherwise.
-bool
-Sema::InstantiateClass(SourceLocation PointOfInstantiation,
-                       CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
+bool Sema::InstantiateClass(SourceLocation PointOfInstantiation,
+                            CXXRecordDecl *Instantiation,
+                            CXXRecordDecl *Pattern,
                             const MultiLevelTemplateArgumentList &TemplateArgs,
-                       TemplateSpecializationKind TSK,
-                       bool Complain) {
+                            bool EarlySubstitution,
+                            TemplateSpecializationKind TSK, bool Complain) {
   CXXRecordDecl *PatternDef
     = cast_or_null<CXXRecordDecl>(Pattern->getDefinition());
   if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Instantiation,
                                 Instantiation->getInstantiatedFromMemberClass(),
                                      Pattern, PatternDef, TSK, Complain))
     return true;
 
   llvm::TimeTraceScope TimeScope("InstantiateClass", [&]() {
bool Sema::InstantiateClass(SourceLocation PointOfInstantiation,
 
   // Some class state isn't processed immediately but delayed till class
   // instantiation completes. We may not be ready to handle any delayed state
   // already on the stack as it might correspond to a different class, so save
   // it now and put it back later.
   SavePendingParsedClassStateRAII SavedPendingParsedClassState(*this);
 
   // Pull attributes from the pattern onto the instantiation.
-  InstantiateAttrs(TemplateArgs, Pattern, Instantiation);
+  InstantiateAttrs(TemplateArgs, EarlySubstitution, Pattern, Instantiation,
+                   /*LateAttrs=*/nullptr,
+                   /*OuterMostScope=*/nullptr);
 
   // Start the definition of this instantiation.
   Instantiation->startDefinition();
 
   // The instantiation is visible here, even if it was first declared in an
   // unimported module.
   Instantiation->setVisibleDespiteOwningModule();
 
   // FIXME: This loses the as-written tag kind for an explicit instantiation.
   Instantiation->setTagKind(Pattern->getTagKind());
 
   // Do substitution on the base class specifiers.
-  if (SubstBaseSpecifiers(Instantiation, Pattern, TemplateArgs))
+  if (SubstBaseSpecifiers(Instantiation, Pattern, TemplateArgs,
+                          EarlySubstitution))
     Instantiation->setInvalidDecl();
 
-  TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs);
+  TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs,
+                                        EarlySubstitution);
   SmallVector<Decl*, 4> Fields;
   // Delay instantiation of late parsed attributes.
   LateInstantiatedAttrVec LateAttrs;
   Instantiator.enableLateAttributeInstantiation(&LateAttrs);
 
   bool MightHaveConstexprVirtualFunctions = false;
   for (auto *Member : Pattern->decls()) {
     // Don't instantiate members not belonging in this semantic context.
for (LateInstantiatedAttrVec::iterator I = LateAttrs.begin(),
     CurrentInstantiationScope = I->Scope;
 
     // Allow 'this' within late-parsed attributes.
     auto *ND = cast<NamedDecl>(I->NewDecl);
     auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
     CXXThisScopeRAII ThisScope(*this, ThisContext, Qualifiers(),
                                ND->isCXXInstanceMember());
 
-    Attr *NewAttr =
-      instantiateTemplateAttribute(I->TmplAttr, Context, *this, TemplateArgs);
+    Attr *NewAttr = instantiateTemplateAttribute(
+        I->TmplAttr, Context, *this, TemplateArgs, EarlySubstitution);
     if (NewAttr)
       I->NewDecl->addAttr(NewAttr);
     LocalInstantiationScope::deleteScopes(I->Scope,
                                           Instantiator.getStartingScope());
   }
   Instantiator.disableLateAttributeInstantiation();
   LateAttrs.clear();
 
   ActOnFinishDelayedMemberInitializers(Instantiation);
 
   // FIXME: We should do something similar for explicit instantiations so they
   // end up in the right module.
   if (TSK == TSK_ImplicitInstantiation) {
     Instantiation->setLocation(Pattern->getLocation());
     Instantiation->setLocStart(Pattern->getInnerLocStart());
     Instantiation->setBraceRange(Pattern->getBraceRange());
   }
 
   if (!Instantiation->isInvalidDecl()) {
     // Perform any dependent diagnostics from the pattern.
     if (Pattern->isDependentContext())
-      PerformDependentDiagnostics(Pattern, TemplateArgs);
+      PerformDependentDiagnostics(Pattern, TemplateArgs, EarlySubstitution);
 
     // Instantiate any out-of-line class template partial
     // specializations now.
     for (TemplateDeclInstantiator::delayed_partial_spec_iterator
               P = Instantiator.delayed_partial_spec_begin(),
            PEnd = Instantiator.delayed_partial_spec_end();
          P != PEnd; ++P) {
       if (!Instantiator.InstantiateClassTemplatePartialSpecialization(

 /// \param TemplateArgs The template arguments to be substituted into
 ///        the pattern.
 /// \param TSK The kind of implicit or explicit instantiation to perform.
 ///
 /// \return \c true if an error occurred, \c false otherwise.
 bool Sema::InstantiateEnum(SourceLocation PointOfInstantiation,
                            EnumDecl *Instantiation, EnumDecl *Pattern,
                            const MultiLevelTemplateArgumentList &TemplateArgs,
+                           bool EarlySubstitution,
                            TemplateSpecializationKind TSK) {
   EnumDecl *PatternDef = Pattern->getDefinition();
   if (DiagnoseUninstantiableTemplate(PointOfInstantiation, Instantiation,
                                  Instantiation->getInstantiatedFromMemberEnum(),
                                      Pattern, PatternDef, TSK,/*Complain*/true))
     return true;
   Pattern = PatternDef;
 
bool Sema::InstantiateEnum(SourceLocation PointOfInstantiation,
   // PushDeclContext because we don't have a scope.
   ContextRAII SavedContext(*this, Instantiation);
   EnterExpressionEvaluationContext EvalContext(
       *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
 
   LocalInstantiationScope Scope(*this, /*MergeWithParentScope*/true);
 
   // Pull attributes from the pattern onto the instantiation.
-  InstantiateAttrs(TemplateArgs, Pattern, Instantiation);
+  InstantiateAttrs(TemplateArgs, EarlySubstitution, Pattern, Instantiation,
+                   /*LateAttrs=*/nullptr,
+                   /*OuterMostScope=*/nullptr);
 
-  TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs);
+  TemplateDeclInstantiator Instantiator(*this, Instantiation, TemplateArgs,
+                                        EarlySubstitution);
   Instantiator.InstantiateEnumDefinition(Instantiation, Pattern);
 
   // Exit the scope of this instantiation.
   SavedContext.pop();
 
   return Instantiation->isInvalidDecl();
 }
 
-
 /// Instantiate the definition of a field from the given pattern.
 ///
 /// \param PointOfInstantiation The point of instantiation within the
 ///        source code.
 /// \param Instantiation is the declaration whose definition is being
 ///        instantiated. This will be a class of a class temploid
 ///        specialization, or a local enumeration within a function temploid
 ///        specialization.
 /// \param Pattern The templated declaration from which the instantiation
 ///        occurs.
 /// \param TemplateArgs The template arguments to be substituted into
 ///        the pattern.
 ///
 /// \return \c true if an error occurred, \c false otherwise.
 bool Sema::InstantiateInClassInitializer(
     SourceLocation PointOfInstantiation, FieldDecl *Instantiation,
-    FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs) {
+    FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs,
+    bool EarlySubstitution) {
   // If there is no initializer, we don't need to do anything.
   if (!Pattern->hasInClassInitializer())
     return false;
 
   assert(Instantiation->getInClassInitStyle() ==
              Pattern->getInClassInitStyle() &&
          "pattern and instantiation disagree about init style");
 
EnterExpressionEvaluationContext EvalContext(
       *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
 
   LocalInstantiationScope Scope(*this, true);
 
   // Instantiate the initializer.
   ActOnStartCXXInClassMemberInitializer();
   CXXThisScopeRAII ThisScope(*this, Instantiation->getParent(), Qualifiers());
 
-  ExprResult NewInit = SubstInitializer(OldInit, TemplateArgs,
-                                        /*CXXDirectInit=*/false);
+  ExprResult NewInit =
+      SubstInitializer(OldInit, TemplateArgs, EarlySubstitution,
   Expr *Init = NewInit.get();
   assert((!Init || !isa<ParenListExpr>(Init)) && "call-style init in class");
   ActOnFinishCXXInClassMemberInitializer(
       Instantiation, Init ? Init->getBeginLoc() : SourceLocation(), Init);
 
   if (auto *L = getASTMutationListener())
     L->DefaultMemberInitializerInstantiated(Instantiation);
 
if (ClassTemplateSpec->isInvalidDecl())
     return true;
 
   ActionResult<CXXRecordDecl *> Pattern =
       getPatternForClassTemplateSpecialization(*this, PointOfInstantiation,
                                                ClassTemplateSpec, TSK);
   if (!Pattern.isUsable())
     return Pattern.isInvalid();
 
-  return InstantiateClass(
-      PointOfInstantiation, ClassTemplateSpec, Pattern.get(),
-      getTemplateInstantiationArgs(ClassTemplateSpec), TSK, Complain);
+  return InstantiateClass(PointOfInstantiation, ClassTemplateSpec,
+                          Pattern.get(),
+                          getTemplateInstantiationArgs(ClassTemplateSpec),
+                          /*EarlySubstitution=*/false, TSK, Complain);
 }
 
 /// Instantiates the definitions of all of the member
 /// of the given class, which is an instantiation of a class template
 /// or a member class of a template.
-void
-Sema::InstantiateClassMembers(SourceLocation PointOfInstantiation,
-                              CXXRecordDecl *Instantiation,
-                        const MultiLevelTemplateArgumentList &TemplateArgs,
-                              TemplateSpecializationKind TSK) {
+void Sema::InstantiateClassMembers(
+    SourceLocation PointOfInstantiation, CXXRecordDecl *Instantiation,
+    const MultiLevelTemplateArgumentList &TemplateArgs, bool EarlySubstitution,
   // FIXME: We need to notify the ASTMutationListener that we did all of these
   // things, in case we have an explicit instantiation definition in a PCM, a
   // module, or preamble, and the declaration is in an imported AST.
   assert(
       (TSK == TSK_ExplicitInstantiationDefinition ||
        TSK == TSK_ExplicitInstantiationDeclaration ||
        (TSK == TSK_ImplicitInstantiation && Instantiation->isLocalClass())) &&
       "Unexpected template specialization kind!");
if (auto *Function = dyn_cast<FunctionDecl>(D)) {
           if (TSK == TSK_ExplicitInstantiationDeclaration) {
             MSInfo->setTemplateSpecializationKind(TSK);
             MSInfo->setPointOfInstantiation(PointOfInstantiation);
           }
 
           continue;
         }
 
-        InstantiateClass(PointOfInstantiation, Record, Pattern,
-                         TemplateArgs,
-                         TSK);
+        InstantiateClass(PointOfInstantiation, Record, Pattern, TemplateArgs,
+                         EarlySubstitution, TSK,
+                         /*Complain=*/true);
       } else {
         if (TSK == TSK_ExplicitInstantiationDefinition &&
             Record->getTemplateSpecializationKind() ==
                 TSK_ExplicitInstantiationDeclaration) {
           Record->setTemplateSpecializationKind(TSK);
           MarkVTableUsed(PointOfInstantiation, Record, true);
         }
       }
 
       Pattern = cast_or_null<CXXRecordDecl>(Record->getDefinition());
       if (Pattern)
         InstantiateClassMembers(PointOfInstantiation, Pattern, TemplateArgs,
-                                TSK);
+                                EarlySubstitution, TSK);
     } else if (auto *Enum = dyn_cast<EnumDecl>(D)) {
       MemberSpecializationInfo *MSInfo = Enum->getMemberSpecializationInfo();
       assert(MSInfo && "No member specialization information?");
 
       if (MSInfo->getTemplateSpecializationKind()
             == TSK_ExplicitSpecialization)
         continue;
 
if (auto *Function = dyn_cast<FunctionDecl>(D)) {
 
       EnumDecl *Pattern = Enum->getTemplateInstantiationPattern();
       assert(Pattern && "Missing instantiated-from-template information");
 
       if (TSK == TSK_ExplicitInstantiationDefinition) {
         if (!Pattern->getDefinition())
           continue;
 
-        InstantiateEnum(PointOfInstantiation, Enum, Pattern, TemplateArgs, TSK);
+        InstantiateEnum(PointOfInstantiation, Enum, Pattern, TemplateArgs,
+                        EarlySubstitution, TSK);
       } else {
         MSInfo->setTemplateSpecializationKind(TSK);
         MSInfo->setPointOfInstantiation(PointOfInstantiation);
       }
     } else if (auto *Field = dyn_cast<FieldDecl>(D)) {
       // No need to instantiate in-class initializers during explicit
       // instantiation.
       if (Field->hasInClassInitializer() && TSK == TSK_ImplicitInstantiation) {
         CXXRecordDecl *ClassPattern =
             Instantiation->getTemplateInstantiationPattern();
         DeclContext::lookup_result Lookup =
             ClassPattern->lookup(Field->getDeclName());
         FieldDecl *Pattern = Lookup.find_first<FieldDecl>();
         assert(Pattern);
         InstantiateInClassInitializer(PointOfInstantiation, Field, Pattern,
-                                      TemplateArgs);
+                                      TemplateArgs, EarlySubstitution);
       }
     }
   }
 }
 
 /// Instantiate the definitions of all of the members of the
 /// given class template specialization, which was named as part of an
 /// explicit instantiation.
 void
 Sema::InstantiateClassTemplateSpecializationMembers(
                                            SourceLocation PointOfInstantiation,
                             ClassTemplateSpecializationDecl *ClassTemplateSpec,
                                                TemplateSpecializationKind TSK) {
   // C++0x [temp.explicit]p7:
   //   An explicit instantiation that names a class template
   //   specialization is an explicit instantion of the same kind
   //   (declaration or definition) of each of its members (not
   //   including members inherited from base classes) that has not
   //   been previously explicitly specialized in the translation unit
   //   containing the explicit instantiation, except as described
   //   below.
   InstantiateClassMembers(PointOfInstantiation, ClassTemplateSpec,
                           getTemplateInstantiationArgs(ClassTemplateSpec),
-                          TSK);
+                          /*EarlySubstitution=*/false, TSK);
 }
 
-StmtResult
-Sema::SubstStmt(Stmt *S, const MultiLevelTemplateArgumentList &TemplateArgs) {
+StmtResult Sema::SubstStmt(Stmt *S,
+                           const MultiLevelTemplateArgumentList &TemplateArgs,
+                           bool EarlySubstitution) {
   if (!S)
     return S;
 
-  TemplateInstantiator Instantiator(*this, TemplateArgs,
-                                    SourceLocation(),
-                                    DeclarationName());
+  TemplateInstantiator Instantiator(*this, TemplateArgs, SourceLocation(),
+                                    DeclarationName(), EarlySubstitution);
   return Instantiator.TransformStmt(S);
 }
 
 bool Sema::SubstTemplateArguments(
     ArrayRef<TemplateArgumentLoc> Args,
-    const MultiLevelTemplateArgumentList &TemplateArgs,
+    const MultiLevelTemplateArgumentList &TemplateArgs, bool EarlySubstitution,
     TemplateArgumentListInfo &Out) {
-  TemplateInstantiator Instantiator(*this, TemplateArgs,
-                                    SourceLocation(),
-                                    DeclarationName());
-  return Instantiator.TransformTemplateArguments(Args.begin(), Args.end(),
-                                                 Out);
+  TemplateInstantiator Instantiator(*this, TemplateArgs, SourceLocation(),
+                                    DeclarationName(), EarlySubstitution);
+  return Instantiator.TransformTemplateArguments(Args.begin(), Args.end(), Out);
 }
 
-ExprResult
-Sema::SubstExpr(Expr *E, const MultiLevelTemplateArgumentList &TemplateArgs) {
+ExprResult Sema::SubstExpr(Expr *E,
+                           const MultiLevelTemplateArgumentList &TemplateArgs,
+                           bool EarlySubstitution) {
   if (!E)
     return E;
 
-  TemplateInstantiator Instantiator(*this, TemplateArgs,
-                                    SourceLocation(),
-                                    DeclarationName());
+  TemplateInstantiator Instantiator(*this, TemplateArgs, SourceLocation(),
+                                    DeclarationName(), EarlySubstitution);
   return Instantiator.TransformExpr(E);
 }
 
-ExprResult Sema::SubstInitializer(Expr *Init,
-                          const MultiLevelTemplateArgumentList &TemplateArgs,
-                          bool CXXDirectInit) {
-  TemplateInstantiator Instantiator(*this, TemplateArgs,
-                                    SourceLocation(),
-                                    DeclarationName());
+ExprResult
+Sema::SubstInitializer(Expr *Init,
+                       bool EarlySubstitution, bool CXXDirectInit) {
+  TemplateInstantiator Instantiator(*this, TemplateArgs, SourceLocation(),
+                                    DeclarationName(), EarlySubstitution);
   return Instantiator.TransformInitializer(Init, CXXDirectInit);
 }
 
 bool Sema::SubstExprs(ArrayRef<Expr *> Exprs, bool IsCall,
                       const MultiLevelTemplateArgumentList &TemplateArgs,
+                      bool EarlySubstitution,
                       SmallVectorImpl<Expr *> &Outputs) {
   if (Exprs.empty())
     return false;
 
-  TemplateInstantiator Instantiator(*this, TemplateArgs,
-                                    SourceLocation(),
-                                    DeclarationName());
-  return Instantiator.TransformExprs(Exprs.data(), Exprs.size(),
-                                     IsCall, Outputs);
+  TemplateInstantiator Instantiator(*this, TemplateArgs, SourceLocation(),
+                                    DeclarationName(), EarlySubstitution);
+  return Instantiator.TransformExprs(Exprs.data(), Exprs.size(), IsCall,
+                                     Outputs);
 }
 
-NestedNameSpecifierLoc
-Sema::SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
-                        const MultiLevelTemplateArgumentList &TemplateArgs) {
+NestedNameSpecifierLoc Sema::SubstNestedNameSpecifierLoc(
+    NestedNameSpecifierLoc NNS,
+    const MultiLevelTemplateArgumentList &TemplateArgs,
+    bool EarlySubstitution) {
   if (!NNS)
     return NestedNameSpecifierLoc();
 
   TemplateInstantiator Instantiator(*this, TemplateArgs, NNS.getBeginLoc(),
-                                    DeclarationName());
+                                    DeclarationName(), EarlySubstitution);
   return Instantiator.TransformNestedNameSpecifierLoc(NNS);
 }
 
 /// Do template substitution on declaration name info.
-DeclarationNameInfo
-Sema::SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
-                         const MultiLevelTemplateArgumentList &TemplateArgs) {
+DeclarationNameInfo Sema::SubstDeclarationNameInfo(
+    const DeclarationNameInfo &NameInfo,
+    const MultiLevelTemplateArgumentList &TemplateArgs,
+    bool EarlySubstitution) {
   TemplateInstantiator Instantiator(*this, TemplateArgs, NameInfo.getLoc(),
-                                    NameInfo.getName());
+                                    NameInfo.getName(), EarlySubstitution);
   return Instantiator.TransformDeclarationNameInfo(NameInfo);
 }
 
 TemplateName
-Sema::SubstTemplateName(NestedNameSpecifierLoc QualifierLoc,
-                        TemplateName Name, SourceLocation Loc,
-                        const MultiLevelTemplateArgumentList &TemplateArgs) {
-  TemplateInstantiator Instantiator(*this, TemplateArgs, Loc,
-                                    DeclarationName());
+Sema::SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name,
+                        SourceLocation Loc,
+                        const MultiLevelTemplateArgumentList &TemplateArgs,
+                        bool EarlySubstitution) {
+  TemplateInstantiator Instantiator(*this, TemplateArgs, Loc, DeclarationName(),
+                                    EarlySubstitution);
   CXXScopeSpec SS;
   SS.Adopt(QualifierLoc);
   return Instantiator.TransformTemplateName(SS, Name, Loc);
 }
 
 static const Decl *getCanonicalParmVarDecl(const Decl *D) {
   // When storing ParmVarDecls in the local instantiation scope, we always
   // want to use the ParmVarDecl from the canonical function declaration,

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

if (DC->isFunctionOrMethod())
     return true;
 
   if (DC->isRecord())
     return cast<CXXRecordDecl>(DC)->isLocalClass();
 
   return false;
 }
 
-template<typename DeclT>
+template <typename DeclT>
 static bool SubstQualifier(Sema &SemaRef, const DeclT *OldDecl, DeclT *NewDecl,
-                           const MultiLevelTemplateArgumentList &TemplateArgs) {
+                           const MultiLevelTemplateArgumentList &TemplateArgs,
+                           bool EarlySubstitution) {
   if (!OldDecl->getQualifierLoc())
     return false;
 
   assert((NewDecl->getFriendObjectKind() ||
           !OldDecl->getLexicalDeclContext()->isDependentContext()) &&
          "non-friend with qualified name defined in dependent context");
   Sema::ContextRAII SavedContext(
       SemaRef,
       const_cast<DeclContext *>(NewDecl->getFriendObjectKind()
                                     ? NewDecl->getLexicalDeclContext()
                                     : OldDecl->getLexicalDeclContext()));
 
-  NestedNameSpecifierLoc NewQualifierLoc
-      = SemaRef.SubstNestedNameSpecifierLoc(OldDecl->getQualifierLoc(),
-                                            TemplateArgs);
+  NestedNameSpecifierLoc NewQualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(
+      OldDecl->getQualifierLoc(), TemplateArgs, EarlySubstitution);
 
   if (!NewQualifierLoc)
     return true;
 
   NewDecl->setQualifierInfo(NewQualifierLoc);
   return false;
 }
 
 bool TemplateDeclInstantiator::SubstQualifier(const DeclaratorDecl *OldDecl,
                                               DeclaratorDecl *NewDecl) {
-  return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
+  return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs,
+                          EarlySubstitution);
 }
 
 bool TemplateDeclInstantiator::SubstQualifier(const TagDecl *OldDecl,
                                               TagDecl *NewDecl) {
-  return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs);
+  return ::SubstQualifier(SemaRef, OldDecl, NewDecl, TemplateArgs,
+                          EarlySubstitution);
 }
 
 // Include attribute instantiation code.
 #include "clang/Sema/AttrTemplateInstantiate.inc"
 
 static void instantiateDependentAlignedAttr(
     Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
-    const AlignedAttr *Aligned, Decl *New, bool IsPackExpansion) {
+    bool EarlySubstitution, const AlignedAttr *Aligned, Decl *New,
+    bool IsPackExpansion) {
   if (Aligned->isAlignmentExpr()) {
     // The alignment expression is a constant expression.
     EnterExpressionEvaluationContext Unevaluated(
         S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
-    ExprResult Result = S.SubstExpr(Aligned->getAlignmentExpr(), TemplateArgs);
+    ExprResult Result = S.SubstExpr(Aligned->getAlignmentExpr(), TemplateArgs,
+                                    EarlySubstitution);
     if (!Result.isInvalid())
       S.AddAlignedAttr(New, *Aligned, Result.getAs<Expr>(), IsPackExpansion);
   } else {
-    TypeSourceInfo *Result = S.SubstType(Aligned->getAlignmentType(),
-                                         TemplateArgs, Aligned->getLocation(),
-                                         DeclarationName());
+    TypeSourceInfo *Result = S.SubstType(
+        Aligned->getAlignmentType(), TemplateArgs, EarlySubstitution,
+        Aligned->getLocation(), DeclarationName(),
+        /*AllowDeducedTST=*/false);
     if (Result)
       S.AddAlignedAttr(New, *Aligned, Result, IsPackExpansion);
   }
 }
 
 static void instantiateDependentAlignedAttr(
     Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
-    const AlignedAttr *Aligned, Decl *New) {
+    bool EarlySubstitution, const AlignedAttr *Aligned, Decl *New) {
   if (!Aligned->isPackExpansion()) {
-    instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false);
+    instantiateDependentAlignedAttr(S, TemplateArgs, EarlySubstitution, Aligned,
+                                    New, /*IsPackExpansion=*/false);
     return;
   }
 
   SmallVector<UnexpandedParameterPack, 2> Unexpanded;
   if (Aligned->isAlignmentExpr())
     S.collectUnexpandedParameterPacks(Aligned->getAlignmentExpr(),
                                       Unexpanded);
   else
     S.collectUnexpandedParameterPacks(Aligned->getAlignmentType()->getTypeLoc(),
                                       Unexpanded);
   assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
 
   // Determine whether we can expand this attribute pack yet.
   bool Expand = true, RetainExpansion = false;
   Optional<unsigned> NumExpansions;
   // FIXME: Use the actual location of the ellipsis.
   SourceLocation EllipsisLoc = Aligned->getLocation();
   if (S.CheckParameterPacksForExpansion(EllipsisLoc, Aligned->getRange(),
                                         Unexpanded, TemplateArgs, Expand,
                                         RetainExpansion, NumExpansions))
     return;
 
   if (!Expand) {
     Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, -1);
-    instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, true);
+    instantiateDependentAlignedAttr(S, TemplateArgs, EarlySubstitution, Aligned,
+                                    New, true);
   } else {
     for (unsigned I = 0; I != *NumExpansions; ++I) {
       Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(S, I);
-      instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false);
+      instantiateDependentAlignedAttr(S, TemplateArgs, EarlySubstitution,
+                                      Aligned, New, false);
     }
   }
 }
 
 static void instantiateDependentAssumeAlignedAttr(
     Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
-    const AssumeAlignedAttr *Aligned, Decl *New) {
+    bool EarlySubstitution, const AssumeAlignedAttr *Aligned, Decl *New) {
   // The alignment expression is a constant expression.
   EnterExpressionEvaluationContext Unevaluated(
       S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
 
   Expr *E, *OE = nullptr;
-  ExprResult Result = S.SubstExpr(Aligned->getAlignment(), TemplateArgs);
+  ExprResult Result =
+      S.SubstExpr(Aligned->getAlignment(), TemplateArgs, EarlySubstitution);
   if (Result.isInvalid())
     return;
   E = Result.getAs<Expr>();
 
   if (Aligned->getOffset()) {
-    Result = S.SubstExpr(Aligned->getOffset(), TemplateArgs);
+    Result = S.SubstExpr(Aligned->getOffset(), TemplateArgs, EarlySubstitution);
     if (Result.isInvalid())
       return;
     OE = Result.getAs<Expr>();
   }
 
   S.AddAssumeAlignedAttr(New, *Aligned, E, OE);
 }
 
 static void instantiateDependentAlignValueAttr(
     Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
-    const AlignValueAttr *Aligned, Decl *New) {
+    bool EarlySubstitution, const AlignValueAttr *Aligned, Decl *New) {
   // The alignment expression is a constant expression.
   EnterExpressionEvaluationContext Unevaluated(
       S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
-  ExprResult Result = S.SubstExpr(Aligned->getAlignment(), TemplateArgs);
+  ExprResult Result =
+      S.SubstExpr(Aligned->getAlignment(), TemplateArgs, EarlySubstitution);
   if (!Result.isInvalid())
     S.AddAlignValueAttr(New, *Aligned, Result.getAs<Expr>());
 }
 
 static void instantiateDependentAllocAlignAttr(
     Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
     const AllocAlignAttr *Align, Decl *New) {
   Expr *Param = IntegerLiteral::Create(
       S.getASTContext(),
       llvm::APInt(64, Align->getParamIndex().getSourceIndex()),
       S.getASTContext().UnsignedLongLongTy, Align->getLocation());
   S.AddAllocAlignAttr(New, *Align, Param);
 }
 
 static void instantiateDependentAnnotationAttr(
     Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
-    const AnnotateAttr *Attr, Decl *New) {
+    bool EarlySubstitution, const AnnotateAttr *Attr, Decl *New) {
   EnterExpressionEvaluationContext Unevaluated(
       S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
 
   // If the attribute has delayed arguments it will have to instantiate those
   // and handle them as new arguments for the attribute.
   bool HasDelayedArgs = Attr->delayedArgs_size();
 
   ArrayRef<Expr *> ArgsToInstantiate =
       HasDelayedArgs
           ? ArrayRef<Expr *>{Attr->delayedArgs_begin(), Attr->delayedArgs_end()}
           : ArrayRef<Expr *>{Attr->args_begin(), Attr->args_end()};
 
   SmallVector<Expr *, 4> Args;
   if (S.SubstExprs(ArgsToInstantiate,
-                   /*IsCall=*/false, TemplateArgs, Args))
+                   /*IsCall=*/false, TemplateArgs, EarlySubstitution, Args))
     return;
 
   StringRef Str = Attr->getAnnotation();
   if (HasDelayedArgs) {
     if (Args.size() < 1) {
       S.Diag(Attr->getLoc(), diag::err_attribute_too_few_arguments)
           << Attr << 1;
       return;
     }
 
     if (!S.checkStringLiteralArgumentAttr(*Attr, Args[0], Str))
       return;
 
     llvm::SmallVector<Expr *, 4> ActualArgs;
     ActualArgs.insert(ActualArgs.begin(), Args.begin() + 1, Args.end());
     std::swap(Args, ActualArgs);
   }
   S.AddAnnotationAttr(New, *Attr, Str, Args);
 }
 
 static Expr *instantiateDependentFunctionAttrCondition(
     Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
-    const Attr *A, Expr *OldCond, const Decl *Tmpl, FunctionDecl *New) {
+    bool EarlySubstitution, const Attr *A, Expr *OldCond, const Decl *Tmpl,
+    FunctionDecl *New) {
   Expr *Cond = nullptr;
   {
     Sema::ContextRAII SwitchContext(S, New);
     EnterExpressionEvaluationContext Unevaluated(
         S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
-    ExprResult Result = S.SubstExpr(OldCond, TemplateArgs);
+    ExprResult Result = S.SubstExpr(OldCond, TemplateArgs, EarlySubstitution);
     if (Result.isInvalid())
       return nullptr;
     Cond = Result.getAs<Expr>();
   }
   if (!Cond->isTypeDependent()) {
     ExprResult Converted = S.PerformContextuallyConvertToBool(Cond);
     if (Converted.isInvalid())
       return nullptr;
     Cond = Converted.get();
   }
 
   SmallVector<PartialDiagnosticAt, 8> Diags;
   if (OldCond->isValueDependent() && !Cond->isValueDependent() &&
       !Expr::isPotentialConstantExprUnevaluated(Cond, New, Diags)) {
     S.Diag(A->getLocation(), diag::err_attr_cond_never_constant_expr) << A;
     for (const auto &P : Diags)
       S.Diag(P.first, P.second);
     return nullptr;
   }
   return Cond;
 }
 
 static void instantiateDependentEnableIfAttr(
     Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
-    const EnableIfAttr *EIA, const Decl *Tmpl, FunctionDecl *New) {
+    bool EarlySubstitution, const EnableIfAttr *EIA, const Decl *Tmpl,
+    FunctionDecl *New) {
   Expr *Cond = instantiateDependentFunctionAttrCondition(
-      S, TemplateArgs, EIA, EIA->getCond(), Tmpl, New);
+      S, TemplateArgs, EarlySubstitution, EIA, EIA->getCond(), Tmpl, New);
 
   if (Cond)
     New->addAttr(new (S.getASTContext()) EnableIfAttr(S.getASTContext(), *EIA,
                                                       Cond, EIA->getMessage()));
 }
 
 static void instantiateDependentDiagnoseIfAttr(
     Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
-    const DiagnoseIfAttr *DIA, const Decl *Tmpl, FunctionDecl *New) {
+    bool EarlySubstitution, const DiagnoseIfAttr *DIA, const Decl *Tmpl,
+    FunctionDecl *New) {
   Expr *Cond = instantiateDependentFunctionAttrCondition(
-      S, TemplateArgs, DIA, DIA->getCond(), Tmpl, New);
+      S, TemplateArgs, EarlySubstitution, DIA, DIA->getCond(), Tmpl, New);
 
   if (Cond)
     New->addAttr(new (S.getASTContext()) DiagnoseIfAttr(
         S.getASTContext(), *DIA, Cond, DIA->getMessage(),
         DIA->getDiagnosticType(), DIA->getArgDependent(), New));
 }
 
 // Constructs and adds to New a new instance of CUDALaunchBoundsAttr using
 // template A as the base and arguments from TemplateArgs.
 static void instantiateDependentCUDALaunchBoundsAttr(
     Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
-    const CUDALaunchBoundsAttr &Attr, Decl *New) {
+    bool EarlySubstitution, const CUDALaunchBoundsAttr &Attr, Decl *New) {
   // The alignment expression is a constant expression.
   EnterExpressionEvaluationContext Unevaluated(
       S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
 
-  ExprResult Result = S.SubstExpr(Attr.getMaxThreads(), TemplateArgs);
+  ExprResult Result =
+      S.SubstExpr(Attr.getMaxThreads(), TemplateArgs, EarlySubstitution);
   if (Result.isInvalid())
     return;
   Expr *MaxThreads = Result.getAs<Expr>();
 
   Expr *MinBlocks = nullptr;
   if (Attr.getMinBlocks()) {
-    Result = S.SubstExpr(Attr.getMinBlocks(), TemplateArgs);
+    Result = S.SubstExpr(Attr.getMinBlocks(), TemplateArgs, EarlySubstitution);
     if (Result.isInvalid())
       return;
     MinBlocks = Result.getAs<Expr>();
   }
 
   S.AddLaunchBoundsAttr(New, Attr, MaxThreads, MinBlocks);
 }
 
-static void
-instantiateDependentModeAttr(Sema &S,
-                             const MultiLevelTemplateArgumentList &TemplateArgs,
-                             const ModeAttr &Attr, Decl *New) {
+static void instantiateDependentModeAttr(Sema &S, const ModeAttr &Attr,
+                                         Decl *New) {
   S.AddModeAttr(New, Attr, Attr.getMode(),
                 /*InInstantiation=*/true);
 }
 
 /// Instantiation of 'declare simd' attribute and its arguments.
 static void instantiateOMPDeclareSimdDeclAttr(
     Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
-    const OMPDeclareSimdDeclAttr &Attr, Decl *New) {
+    bool EarlySubstitution, const OMPDeclareSimdDeclAttr &Attr, Decl *New) {
   // Allow 'this' in clauses with varlists.
   if (auto *FTD = dyn_cast<FunctionTemplateDecl>(New))
     New = FTD->getTemplatedDecl();
   auto *FD = cast<FunctionDecl>(New);
   auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(FD->getDeclContext());
   SmallVector<Expr *, 4> Uniforms, Aligneds, Alignments, Linears, Steps;
   SmallVector<unsigned, 4> LinModifiers;
 
   auto SubstExpr = [&](Expr *E) -> ExprResult {
     if (auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts()))
       if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
         Sema::ContextRAII SavedContext(S, FD);
         LocalInstantiationScope Local(S);
         if (FD->getNumParams() > PVD->getFunctionScopeIndex())
           Local.InstantiatedLocal(
               PVD, FD->getParamDecl(PVD->getFunctionScopeIndex()));
-        return S.SubstExpr(E, TemplateArgs);
+        return S.SubstExpr(E, TemplateArgs, EarlySubstitution);
       }
     Sema::CXXThisScopeRAII ThisScope(S, ThisContext, Qualifiers(),
                                      FD->isCXXInstanceMember());
-    return S.SubstExpr(E, TemplateArgs);
+    return S.SubstExpr(E, TemplateArgs, EarlySubstitution);
   };
 
   // Substitute a single OpenMP clause, which is a potentially-evaluated
   // full-expression.
   auto Subst = [&](Expr *E) -> ExprResult {
     EnterExpressionEvaluationContext Evaluated(
         S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
     ExprResult Res = SubstExpr(E);
static void instantiateOMPDeclareSimdDeclAttr(
   auto AI = Attr.alignments_begin();
   for (auto *E : Attr.aligneds()) {
     ExprResult Inst = Subst(E);
     if (Inst.isInvalid())
       continue;
     Aligneds.push_back(Inst.get());
     Inst = ExprEmpty();
     if (*AI)
-      Inst = S.SubstExpr(*AI, TemplateArgs);
+      Inst = S.SubstExpr(*AI, TemplateArgs, EarlySubstitution);
     Alignments.push_back(Inst.get());
     ++AI;
   }
 
   auto SI = Attr.steps_begin();
   for (auto *E : Attr.linears()) {
     ExprResult Inst = Subst(E);
     if (Inst.isInvalid())
       continue;
     Linears.push_back(Inst.get());
     Inst = ExprEmpty();
     if (*SI)
-      Inst = S.SubstExpr(*SI, TemplateArgs);
+      Inst = S.SubstExpr(*SI, TemplateArgs, EarlySubstitution);
     Steps.push_back(Inst.get());
     ++SI;
   }
   LinModifiers.append(Attr.modifiers_begin(), Attr.modifiers_end());
   (void)S.ActOnOpenMPDeclareSimdDirective(
       S.ConvertDeclToDeclGroup(New), Attr.getBranchState(), Simdlen.get(),
       Uniforms, Aligneds, Alignments, Linears, LinModifiers, Steps,
       Attr.getRange());
 }
 
 /// Instantiation of 'declare variant' attribute and its arguments.
 static void instantiateOMPDeclareVariantAttr(
     Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
-    const OMPDeclareVariantAttr &Attr, Decl *New) {
+    bool EarlySubstitution, const OMPDeclareVariantAttr &Attr, Decl *New) {
   // Allow 'this' in clauses with varlists.
   if (auto *FTD = dyn_cast<FunctionTemplateDecl>(New))
     New = FTD->getTemplatedDecl();
   auto *FD = cast<FunctionDecl>(New);
   auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(FD->getDeclContext());
 
-  auto &&SubstExpr = [FD, ThisContext, &S, &TemplateArgs](Expr *E) {
+  auto &&SubstExpr = [FD, ThisContext, &S, &TemplateArgs,
+                      &EarlySubstitution](Expr *E) {
     if (auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts()))
       if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
         Sema::ContextRAII SavedContext(S, FD);
         LocalInstantiationScope Local(S);
         if (FD->getNumParams() > PVD->getFunctionScopeIndex())
           Local.InstantiatedLocal(
               PVD, FD->getParamDecl(PVD->getFunctionScopeIndex()));
-        return S.SubstExpr(E, TemplateArgs);
+        return S.SubstExpr(E, TemplateArgs, EarlySubstitution);
       }
     Sema::CXXThisScopeRAII ThisScope(S, ThisContext, Qualifiers(),
                                      FD->isCXXInstanceMember());
-    return S.SubstExpr(E, TemplateArgs);
+    return S.SubstExpr(E, TemplateArgs, EarlySubstitution);
   };
 
   // Substitute a single OpenMP clause, which is a potentially-evaluated
   // full-expression.
   auto &&Subst = [&SubstExpr, &S](Expr *E) {
     EnterExpressionEvaluationContext Evaluated(
         S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
     ExprResult Res = SubstExpr(E);
if (auto *VariantDRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts())) {
     if (auto *VariantFD = dyn_cast<FunctionDecl>(VariantDRE->getDecl())) {
       if (auto *VariantFTD = VariantFD->getDescribedFunctionTemplate()) {
         if (!VariantFTD->isThisDeclarationADefinition())
           return;
         Sema::TentativeAnalysisScope Trap(S);
         const TemplateArgumentList *TAL = TemplateArgumentList::CreateCopy(
             S.Context, TemplateArgs.getInnermost());
 
-        auto *SubstFD = S.InstantiateFunctionDeclaration(VariantFTD, TAL,
-                                                         New->getLocation());
+        auto *SubstFD = S.InstantiateFunctionDeclaration(
+            VariantFTD, TAL, EarlySubstitution, New->getLocation());
         if (!SubstFD)
           return;
         QualType NewType = S.Context.mergeFunctionTypes(
             SubstFD->getType(), FD->getType(),
             /* OfBlockPointer */ false,
             /* Unqualified */ false, /* AllowCXX */ true);
         if (NewType.isNull())
           return;
static void instantiateOMPDeclareVariantAttr(
 
   S.ActOnOpenMPDeclareVariantDirective(
       FD, E, TI, NothingExprs, NeedDevicePtrExprs, AppendArgs, SourceLocation(),
       SourceLocation(), Attr.getRange());
 }
 
 static void instantiateDependentAMDGPUFlatWorkGroupSizeAttr(
     Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
-    const AMDGPUFlatWorkGroupSizeAttr &Attr, Decl *New) {
+    bool EarlySubstitution, const AMDGPUFlatWorkGroupSizeAttr &Attr,
+    Decl *New) {
   // Both min and max expression are constant expressions.
   EnterExpressionEvaluationContext Unevaluated(
       S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
 
-  ExprResult Result = S.SubstExpr(Attr.getMin(), TemplateArgs);
+  ExprResult Result =
+      S.SubstExpr(Attr.getMin(), TemplateArgs, EarlySubstitution);
   if (Result.isInvalid())
     return;
   Expr *MinExpr = Result.getAs<Expr>();
 
-  Result = S.SubstExpr(Attr.getMax(), TemplateArgs);
+  Result = S.SubstExpr(Attr.getMax(), TemplateArgs, EarlySubstitution);
   if (Result.isInvalid())
     return;
   Expr *MaxExpr = Result.getAs<Expr>();
 
   S.addAMDGPUFlatWorkGroupSizeAttr(New, Attr, MinExpr, MaxExpr);
 }
 
-static ExplicitSpecifier
-instantiateExplicitSpecifier(Sema &S,
-                             const MultiLevelTemplateArgumentList &TemplateArgs,
-                             ExplicitSpecifier ES, FunctionDecl *New) {
+static ExplicitSpecifier instantiateExplicitSpecifier(
+    Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
+    bool EarlySubstitution, ExplicitSpecifier ES, FunctionDecl *New) {
   if (!ES.getExpr())
     return ES;
   Expr *OldCond = ES.getExpr();
   Expr *Cond = nullptr;
   {
     EnterExpressionEvaluationContext Unevaluated(
         S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
-    ExprResult SubstResult = S.SubstExpr(OldCond, TemplateArgs);
+    ExprResult SubstResult =
+        S.SubstExpr(OldCond, TemplateArgs, EarlySubstitution);
     if (SubstResult.isInvalid()) {
       return ExplicitSpecifier::Invalid();
     }
     Cond = SubstResult.get();
   }
   ExplicitSpecifier Result(Cond, ES.getKind());
   if (!Cond->isTypeDependent())
     S.tryResolveExplicitSpecifier(Result);
   return Result;
 }
 
 static void instantiateDependentAMDGPUWavesPerEUAttr(
     Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
-    const AMDGPUWavesPerEUAttr &Attr, Decl *New) {
+    bool EarlySubstitution, const AMDGPUWavesPerEUAttr &Attr, Decl *New) {
   // Both min and max expression are constant expressions.
   EnterExpressionEvaluationContext Unevaluated(
       S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
 
-  ExprResult Result = S.SubstExpr(Attr.getMin(), TemplateArgs);
+  ExprResult Result =
+      S.SubstExpr(Attr.getMin(), TemplateArgs, EarlySubstitution);
   if (Result.isInvalid())
     return;
   Expr *MinExpr = Result.getAs<Expr>();
 
   Expr *MaxExpr = nullptr;
   if (auto Max = Attr.getMax()) {
-    Result = S.SubstExpr(Max, TemplateArgs);
+    Result = S.SubstExpr(Max, TemplateArgs, EarlySubstitution);
     if (Result.isInvalid())
       return;
     MaxExpr = Result.getAs<Expr>();
   }
 
   S.addAMDGPUWavesPerEUAttr(New, Attr, MinExpr, MaxExpr);
 }
 
 // This doesn't take any template parameters, but we have a custom action that
 // needs to happen when the kernel itself is instantiated. We need to run the
 // ItaniumMangler to mark the names required to name this kernel.
-static void instantiateDependentSYCLKernelAttr(
-    Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
-    const SYCLKernelAttr &Attr, Decl *New) {
+static void instantiateDependentSYCLKernelAttr(Sema &S,
+                                               const SYCLKernelAttr &Attr,
+                                               Decl *New) {
   New->addAttr(Attr.clone(S.getASTContext()));
 }
 
 /// Determine whether the attribute A might be relevant to the declaration D.
 /// If not, we can skip instantiating it. The attribute may or may not have
 /// been instantiated yet.
 static bool isRelevantAttr(Sema &S, const Decl *D, const Attr *A) {
   // 'preferred_name' is only relevant to the matching specialization of the
case Builtin::BImove_if_noexcept:
       break;
     }
   }
 
   return true;
 }
 
 void Sema::InstantiateAttrsForDecl(
-    const MultiLevelTemplateArgumentList &TemplateArgs, const Decl *Tmpl,
-    Decl *New, LateInstantiatedAttrVec *LateAttrs,
+    const MultiLevelTemplateArgumentList &TemplateArgs, bool EarlySubstitution,
+    const Decl *Tmpl, Decl *New, LateInstantiatedAttrVec *LateAttrs,
     LocalInstantiationScope *OuterMostScope) {
   if (NamedDecl *ND = dyn_cast<NamedDecl>(New)) {
     // FIXME: This function is called multiple times for the same template
     // specialization. We should only instantiate attributes that were added
     // since the previous instantiation.
     for (const auto *TmplAttr : Tmpl->attrs()) {
       if (!isRelevantAttr(*this, New, TmplAttr))
         continue;
 
       // FIXME: If any of the special case versions from InstantiateAttrs become
       // applicable to template declaration, we'll need to add them here.
       CXXThisScopeRAII ThisScope(
           *this, dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext()),
           Qualifiers(), ND->isCXXInstanceMember());
 
       Attr *NewAttr = sema::instantiateTemplateAttributeForDecl(
-          TmplAttr, Context, *this, TemplateArgs);
+          TmplAttr, Context, *this, TemplateArgs, EarlySubstitution);
       if (NewAttr && isRelevantAttr(*this, New, NewAttr))
         New->addAttr(NewAttr);
     }
   }
 }
 
 static Sema::RetainOwnershipKind
 attrToRetainOwnershipKind(const Attr *A) {
   switch (A->getKind()) {
   case clang::attr::CFConsumed:
     return Sema::RetainOwnershipKind::CF;
   case clang::attr::OSConsumed:
     return Sema::RetainOwnershipKind::OS;
   case clang::attr::NSConsumed:
     return Sema::RetainOwnershipKind::NS;
   default:
     llvm_unreachable("Wrong argument supplied");
   }
 }
 
 void Sema::InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
-                            const Decl *Tmpl, Decl *New,
+                            bool EarlySubstitution, const Decl *Tmpl, Decl *New,
                             LateInstantiatedAttrVec *LateAttrs,
                             LocalInstantiationScope *OuterMostScope) {
   for (const auto *TmplAttr : Tmpl->attrs()) {
     if (!isRelevantAttr(*this, New, TmplAttr))
       continue;
 
     // FIXME: This should be generalized to more than just the AlignedAttr.
     const AlignedAttr *Aligned = dyn_cast<AlignedAttr>(TmplAttr);
     if (Aligned && Aligned->isAlignmentDependent()) {
-      instantiateDependentAlignedAttr(*this, TemplateArgs, Aligned, New);
+      instantiateDependentAlignedAttr(*this, TemplateArgs, EarlySubstitution,
+                                      Aligned, New);
       continue;
     }
 
     if (const auto *AssumeAligned = dyn_cast<AssumeAlignedAttr>(TmplAttr)) {
-      instantiateDependentAssumeAlignedAttr(*this, TemplateArgs, AssumeAligned, New);
+      instantiateDependentAssumeAlignedAttr(
+          *this, TemplateArgs, EarlySubstitution, AssumeAligned, New);
       continue;
     }
 
     if (const auto *AlignValue = dyn_cast<AlignValueAttr>(TmplAttr)) {
-      instantiateDependentAlignValueAttr(*this, TemplateArgs, AlignValue, New);
+      instantiateDependentAlignValueAttr(*this, TemplateArgs, EarlySubstitution,
+                                         AlignValue, New);
       continue;
     }
 
     if (const auto *AllocAlign = dyn_cast<AllocAlignAttr>(TmplAttr)) {
       instantiateDependentAllocAlignAttr(*this, TemplateArgs, AllocAlign, New);
       continue;
     }
 
     if (const auto *Annotate = dyn_cast<AnnotateAttr>(TmplAttr)) {
-      instantiateDependentAnnotationAttr(*this, TemplateArgs, Annotate, New);
+      instantiateDependentAnnotationAttr(*this, TemplateArgs, EarlySubstitution,
+                                         Annotate, New);
       continue;
     }
 
     if (const auto *EnableIf = dyn_cast<EnableIfAttr>(TmplAttr)) {
-      instantiateDependentEnableIfAttr(*this, TemplateArgs, EnableIf, Tmpl,
-                                       cast<FunctionDecl>(New));
+      instantiateDependentEnableIfAttr(*this, TemplateArgs, EarlySubstitution,
+                                       EnableIf, Tmpl, cast<FunctionDecl>(New));
       continue;
     }
 
     if (const auto *DiagnoseIf = dyn_cast<DiagnoseIfAttr>(TmplAttr)) {
-      instantiateDependentDiagnoseIfAttr(*this, TemplateArgs, DiagnoseIf, Tmpl,
+      instantiateDependentDiagnoseIfAttr(*this, TemplateArgs, EarlySubstitution,
+                                         DiagnoseIf, Tmpl,
                                          cast<FunctionDecl>(New));
       continue;
     }
 
     if (const auto *CUDALaunchBounds =
             dyn_cast<CUDALaunchBoundsAttr>(TmplAttr)) {
-      instantiateDependentCUDALaunchBoundsAttr(*this, TemplateArgs,
-                                               *CUDALaunchBounds, New);
+      instantiateDependentCUDALaunchBoundsAttr(
+          *this, TemplateArgs, EarlySubstitution, *CUDALaunchBounds, New);
       continue;
     }
 
     if (const auto *Mode = dyn_cast<ModeAttr>(TmplAttr)) {
-      instantiateDependentModeAttr(*this, TemplateArgs, *Mode, New);
+      instantiateDependentModeAttr(*this, *Mode, New);
       continue;
     }
 
     if (const auto *OMPAttr = dyn_cast<OMPDeclareSimdDeclAttr>(TmplAttr)) {
-      instantiateOMPDeclareSimdDeclAttr(*this, TemplateArgs, *OMPAttr, New);
+      instantiateOMPDeclareSimdDeclAttr(*this, TemplateArgs, EarlySubstitution,
+                                        *OMPAttr, New);
       continue;
     }
 
     if (const auto *OMPAttr = dyn_cast<OMPDeclareVariantAttr>(TmplAttr)) {
-      instantiateOMPDeclareVariantAttr(*this, TemplateArgs, *OMPAttr, New);
+      instantiateOMPDeclareVariantAttr(*this, TemplateArgs, EarlySubstitution,
+                                       *OMPAttr, New);
       continue;
     }
 
     if (const auto *AMDGPUFlatWorkGroupSize =
             dyn_cast<AMDGPUFlatWorkGroupSizeAttr>(TmplAttr)) {
       instantiateDependentAMDGPUFlatWorkGroupSizeAttr(
-          *this, TemplateArgs, *AMDGPUFlatWorkGroupSize, New);
+          *this, TemplateArgs, EarlySubstitution, *AMDGPUFlatWorkGroupSize,
+          New);
     }
 
     if (const auto *AMDGPUFlatWorkGroupSize =
             dyn_cast<AMDGPUWavesPerEUAttr>(TmplAttr)) {
       instantiateDependentAMDGPUWavesPerEUAttr(*this, TemplateArgs,
+                                               EarlySubstitution,
                                                *AMDGPUFlatWorkGroupSize, New);
     }
 
     // Existing DLL attribute on the instantiation takes precedence.
     if (TmplAttr->getKind() == attr::DLLExport ||
         TmplAttr->getKind() == attr::DLLImport) {
       if (New->hasAttr<DLLExportAttr>() || New->hasAttr<DLLImportAttr>()) {
         continue;
for (const auto *TmplAttr : Tmpl->attrs()) {
 
     if (auto *A = dyn_cast<OwnerAttr>(TmplAttr)) {
       if (!New->hasAttr<OwnerAttr>())
         New->addAttr(A->clone(Context));
       continue;
     }
 
     if (auto *A = dyn_cast<SYCLKernelAttr>(TmplAttr)) {
-      instantiateDependentSYCLKernelAttr(*this, TemplateArgs, *A, New);
+      instantiateDependentSYCLKernelAttr(*this, *A, New);
       continue;
     }
 
     assert(!TmplAttr->isPackExpansion());
     if (TmplAttr->isLateParsed() && LateAttrs) {
       // Late parsed attributes must be instantiated and attached after the
       // enclosing class has been instantiated.  See Sema::InstantiateClass.
       LocalInstantiationScope *Saved = nullptr;
       if (CurrentInstantiationScope)
         Saved = CurrentInstantiationScope->cloneScopes(OuterMostScope);
       LateAttrs->push_back(LateInstantiatedAttribute(TmplAttr, Saved, New));
     } else {
       // Allow 'this' within late-parsed attributes.
       auto *ND = cast<NamedDecl>(New);
       auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(ND->getDeclContext());
       CXXThisScopeRAII ThisScope(*this, ThisContext, Qualifiers(),
                                  ND->isCXXInstanceMember());
 
-      Attr *NewAttr = sema::instantiateTemplateAttribute(TmplAttr, Context,
-                                                         *this, TemplateArgs);
+      Attr *NewAttr = sema::instantiateTemplateAttribute(
+          TmplAttr, Context, *this, TemplateArgs, EarlySubstitution);
       if (NewAttr && isRelevantAttr(*this, New, TmplAttr))
         New->addAttr(NewAttr);
     }
   }
 }
 
 /// In the MS ABI, we need to instantiate default arguments of dllexported
 /// default constructors along with the constructor definition. This allows IR

 }
 
 Decl *TemplateDeclInstantiator::InstantiateTypedefNameDecl(TypedefNameDecl *D,
                                                            bool IsTypeAlias) {
   bool Invalid = false;
   TypeSourceInfo *DI = D->getTypeSourceInfo();
   if (DI->getType()->isInstantiationDependentType() ||
       DI->getType()->isVariablyModifiedType()) {
-    DI = SemaRef.SubstType(DI, TemplateArgs,
-                           D->getLocation(), D->getDeclName());
+    DI = SemaRef.SubstType(DI, TemplateArgs, EarlySubstitution,
+                           D->getLocation(), D->getDeclName(),
+                           /*AllowDeducedTST=*/false);
     if (!DI) {
       Invalid = true;
       DI = SemaRef.Context.getTrivialTypeSourceInfo(SemaRef.Context.IntTy);
     }
   } else {
     SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
   }
 
if (const TagType *oldTagType = D->getUnderlyingType()->getAs<TagType>()) {
     if (oldTag->getTypedefNameForAnonDecl() == D && !Invalid) {
       TagDecl *newTag = DI->getType()->castAs<TagType>()->getDecl();
       assert(!newTag->hasNameForLinkage());
       newTag->setTypedefNameForAnonDecl(Typedef);
     }
   }
 
   if (TypedefNameDecl *Prev = getPreviousDeclForInstantiation(D)) {
-    NamedDecl *InstPrev = SemaRef.FindInstantiatedDecl(D->getLocation(), Prev,
-                                                       TemplateArgs);
+    NamedDecl *InstPrev = SemaRef.FindInstantiatedDecl(
+        D->getLocation(), Prev, TemplateArgs, EarlySubstitution,
+        /*FindingInstantiatedContext=*/false);
     if (!InstPrev)
       return nullptr;
 
     TypedefNameDecl *InstPrevTypedef = cast<TypedefNameDecl>(InstPrev);
 
     // If the typedef types are not identical, reject them.
     SemaRef.isIncompatibleTypedef(InstPrevTypedef, Typedef);
 
     Typedef->setPreviousDecl(InstPrevTypedef);
   }
 
-  SemaRef.InstantiateAttrs(TemplateArgs, D, Typedef);
+  SemaRef.InstantiateAttrs(TemplateArgs, EarlySubstitution, D, Typedef,
+                           /*LateAttrs=*/nullptr,
+                           /*OuterMostScope=*/nullptr);
 
   if (D->getUnderlyingType()->getAs<DependentNameType>())
     SemaRef.inferGslPointerAttribute(Typedef);
 
   Typedef->setAccess(D->getAccess());
   Typedef->setReferenced(D->isReferenced());
 
   return Typedef;
Decl *TemplateDeclInstantiator::VisitTypeAliasDecl(TypeAliasDecl *D) {
   return Typedef;
 }
 
 Decl *
 TemplateDeclInstantiator::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
   // Create a local instantiation scope for this type alias template, which
   // will contain the instantiations of the template parameters.
   LocalInstantiationScope Scope(SemaRef);
+  auto EarlySubstitutionScope = getEarlySubstitutionRAII();
 
-  TemplateParameterList *TempParams = D->getTemplateParameters();
-  TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
+  TemplateParameterList *InstParams =
+      SubstTemplateParams(D->getTemplateParameters());
   if (!InstParams)
     return nullptr;
 
   TypeAliasDecl *Pattern = D->getTemplatedDecl();
 
   TypeAliasTemplateDecl *PrevAliasTemplate = nullptr;
   if (getPreviousDeclForInstantiation<TypedefNameDecl>(Pattern)) {
     DeclContext::lookup_result Found = Owner->lookup(Pattern->getDeclName());
     if (!Found.empty()) {
       PrevAliasTemplate = dyn_cast<TypeAliasTemplateDecl>(Found.front());
     }
   }
 
   TypeAliasDecl *AliasInst = cast_or_null<TypeAliasDecl>(
       InstantiateTypedefNameDecl(Pattern, /*IsTypeAlias=*/true));
   if (!AliasInst)
     return nullptr;
 
-  TypeAliasTemplateDecl *Inst
-    = TypeAliasTemplateDecl::Create(SemaRef.Context, Owner, D->getLocation(),
+  TypeAliasTemplateDecl *Inst =
+      TypeAliasTemplateDecl::Create(SemaRef.Context, Owner, D->getLocation(),
                                     D->getDeclName(), InstParams, AliasInst);
   AliasInst->setDescribedAliasTemplate(Inst);
   if (PrevAliasTemplate)
     Inst->setPreviousDecl(PrevAliasTemplate);
 
   Inst->setAccess(D->getAccess());
 
   if (!PrevAliasTemplate)

 }
 
 Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D,
                                              bool InstantiatingVarTemplate,
                                              ArrayRef<BindingDecl*> *Bindings) {
 
   // Do substitution on the type of the declaration
   TypeSourceInfo *DI = SemaRef.SubstType(
-      D->getTypeSourceInfo(), TemplateArgs, D->getTypeSpecStartLoc(),
-      D->getDeclName(), /*AllowDeducedTST*/true);
+      D->getTypeSourceInfo(), TemplateArgs, EarlySubstitution,
+      D->getTypeSpecStartLoc(), D->getDeclName(), /*AllowDeducedTST=*/true);
   if (!DI)
     return nullptr;
 
   if (DI->getType()->isFunctionType()) {
     SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
       << D->isStaticDataMember() << DI->getType();
     return nullptr;
   }
Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D,
 
   if (SemaRef.getLangOpts().OpenCL)
     SemaRef.deduceOpenCLAddressSpace(Var);
 
   // Substitute the nested name specifier, if any.
   if (SubstQualifier(D, Var))
     return nullptr;
 
-  SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs, Owner,
-                                     StartingScope, InstantiatingVarTemplate);
+  SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, EarlySubstitution,
+                                     LateAttrs, Owner, StartingScope,
+                                     InstantiatingVarTemplate,
+                                     /*PrevVTSD=*/nullptr);
   if (D->isNRVOVariable() && !Var->isInvalidDecl()) {
     QualType RT;
     if (auto *F = dyn_cast<FunctionDecl>(DC))
       RT = F->getReturnType();
     else if (isa<BlockDecl>(DC))
       RT = cast<FunctionType>(SemaRef.getCurBlock()->FunctionType)
                ->getReturnType();
     else
Decl *TemplateDeclInstantiator::VisitAccessSpecDecl(AccessSpecDecl *D) {
   return AD;
 }
 
 Decl *TemplateDeclInstantiator::VisitFieldDecl(FieldDecl *D) {
   bool Invalid = false;
   TypeSourceInfo *DI = D->getTypeSourceInfo();
   if (DI->getType()->isInstantiationDependentType() ||
       DI->getType()->isVariablyModifiedType())  {
-    DI = SemaRef.SubstType(DI, TemplateArgs,
-                           D->getLocation(), D->getDeclName());
+    DI = SemaRef.SubstType(DI, TemplateArgs, EarlySubstitution,
+                           D->getLocation(), D->getDeclName(),
+                           /*AllowDeducedTST=*/false);
     if (!DI) {
       DI = D->getTypeSourceInfo();
       Invalid = true;
     } else if (DI->getType()->isFunctionType()) {
       // C++ [temp.arg.type]p3:
       //   If a declaration acquires a function type through a type
       //   dependent on a template-parameter and this causes a
       //   declaration that does not use the syntactic form of a
Decl *TemplateDeclInstantiator::VisitFieldDecl(FieldDecl *D) {
   Expr *BitWidth = D->getBitWidth();
   if (Invalid)
     BitWidth = nullptr;
   else if (BitWidth) {
     // The bit-width expression is a constant expression.
     EnterExpressionEvaluationContext Unevaluated(
         SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
 
-    ExprResult InstantiatedBitWidth
-      = SemaRef.SubstExpr(BitWidth, TemplateArgs);
+    ExprResult InstantiatedBitWidth =
+        SemaRef.SubstExpr(BitWidth, TemplateArgs, EarlySubstitution);
     if (InstantiatedBitWidth.isInvalid()) {
       Invalid = true;
       BitWidth = nullptr;
     } else
       BitWidth = InstantiatedBitWidth.getAs<Expr>();
   }
 
   FieldDecl *Field = SemaRef.CheckFieldDecl(D->getDeclName(),
                                             DI->getType(), DI,
                                             cast<RecordDecl>(Owner),
                                             D->getLocation(),
                                             D->isMutable(),
                                             BitWidth,
                                             D->getInClassInitStyle(),
                                             D->getInnerLocStart(),
                                             D->getAccess(),
                                             nullptr);
   if (!Field) {
     cast<Decl>(Owner)->setInvalidDecl();
     return nullptr;
   }
 
-  SemaRef.InstantiateAttrs(TemplateArgs, D, Field, LateAttrs, StartingScope);
+  SemaRef.InstantiateAttrs(TemplateArgs, EarlySubstitution, D, Field, LateAttrs,
+                           StartingScope);
 
   if (Field->hasAttrs())
     SemaRef.CheckAlignasUnderalignment(Field);
 
   if (Invalid)
     Field->setInvalidDecl();
 
   if (!Field->getDeclName()) {
Decl *TemplateDeclInstantiator::VisitMSPropertyDecl(MSPropertyDecl *D) {
   bool Invalid = false;
   TypeSourceInfo *DI = D->getTypeSourceInfo();
 
   if (DI->getType()->isVariablyModifiedType()) {
     SemaRef.Diag(D->getLocation(), diag::err_property_is_variably_modified)
       << D;
     Invalid = true;
   } else if (DI->getType()->isInstantiationDependentType())  {
-    DI = SemaRef.SubstType(DI, TemplateArgs,
-                           D->getLocation(), D->getDeclName());
+    DI = SemaRef.SubstType(DI, TemplateArgs, EarlySubstitution,
+                           D->getLocation(), D->getDeclName(),
+                           /*AllowDeducedTST=*/false);
     if (!DI) {
       DI = D->getTypeSourceInfo();
       Invalid = true;
     } else if (DI->getType()->isFunctionType()) {
       // C++ [temp.arg.type]p3:
       //   If a declaration acquires a function type through a type
       //   dependent on a template-parameter and this causes a
       //   declaration that does not use the syntactic form of a
       //   function declarator to have function type, the program is
       //   ill-formed.
       SemaRef.Diag(D->getLocation(), diag::err_field_instantiates_to_function)
       << DI->getType();
       Invalid = true;
     }
   } else {
     SemaRef.MarkDeclarationsReferencedInType(D->getLocation(), DI->getType());
   }
 
   MSPropertyDecl *Property = MSPropertyDecl::Create(
       SemaRef.Context, Owner, D->getLocation(), D->getDeclName(), DI->getType(),
       DI, D->getBeginLoc(), D->getGetterId(), D->getSetterId());
 
-  SemaRef.InstantiateAttrs(TemplateArgs, D, Property, LateAttrs,
-                           StartingScope);
+  SemaRef.InstantiateAttrs(TemplateArgs, EarlySubstitution, D, Property,
+                           LateAttrs, StartingScope);
 
   if (Invalid)
     Property->setInvalidDecl();
 
   Property->setAccess(D->getAccess());
   Owner->addDecl(Property);
 
   return Property;
 }
 
 Decl *TemplateDeclInstantiator::VisitIndirectFieldDecl(IndirectFieldDecl *D) {
   NamedDecl **NamedChain =
     new (SemaRef.Context)NamedDecl*[D->getChainingSize()];
 
   int i = 0;
   for (auto *PI : D->chain()) {
-    NamedDecl *Next = SemaRef.FindInstantiatedDecl(D->getLocation(), PI,
-                                              TemplateArgs);
+    NamedDecl *Next = SemaRef.FindInstantiatedDecl(
+        D->getLocation(), PI, TemplateArgs, EarlySubstitution,
+        /*FindingInstantiatedContext=*/false);
     if (!Next)
       return nullptr;
 
     NamedChain[i++] = Next;
   }
 
   QualType T = cast<FieldDecl>(NamedChain[i-1])->getType();
   IndirectFieldDecl *IndirectField = IndirectFieldDecl::Create(
if (TypeSourceInfo *Ty = D->getFriendType()) {
     TypeSourceInfo *InstTy;
     // If this is an unsupported friend, don't bother substituting template
     // arguments into it. The actual type referred to won't be used by any
     // parts of Clang, and may not be valid for instantiating. Just use the
     // same info for the instantiated friend.
     if (D->isUnsupportedFriend()) {
       InstTy = Ty;
     } else {
-      InstTy = SemaRef.SubstType(Ty, TemplateArgs,
-                                 D->getLocation(), DeclarationName());
+      InstTy = SemaRef.SubstType(Ty, TemplateArgs, EarlySubstitution,
+                                 D->getLocation(), DeclarationName(),
+                                 /*AllowDeducedTST=*/false);
     }
     if (!InstTy)
       return nullptr;
 
     FriendDecl *FD = SemaRef.CheckFriendTypeDecl(D->getBeginLoc(),
                                                  D->getFriendLoc(), InstTy);
     if (!FD)
       return nullptr;

 
 Decl *TemplateDeclInstantiator::VisitStaticAssertDecl(StaticAssertDecl *D) {
   Expr *AssertExpr = D->getAssertExpr();
 
   // The expression in a static assertion is a constant expression.
   EnterExpressionEvaluationContext Unevaluated(
       SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
 
-  ExprResult InstantiatedAssertExpr
-    = SemaRef.SubstExpr(AssertExpr, TemplateArgs);
+  ExprResult InstantiatedAssertExpr =
+      SemaRef.SubstExpr(AssertExpr, TemplateArgs, EarlySubstitution);
   if (InstantiatedAssertExpr.isInvalid())
     return nullptr;
 
   return SemaRef.BuildStaticAssertDeclaration(D->getLocation(),
                                               InstantiatedAssertExpr.get(),
                                               D->getMessage(),
                                               D->getRParenLoc(),
                                               D->isFailed());
 }
 
 Decl *TemplateDeclInstantiator::VisitEnumDecl(EnumDecl *D) {
   EnumDecl *PrevDecl = nullptr;
   if (EnumDecl *PatternPrev = getPreviousDeclForInstantiation(D)) {
-    NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
-                                                   PatternPrev,
-                                                   TemplateArgs);
+    NamedDecl *Prev = SemaRef.FindInstantiatedDecl(
+        D->getLocation(), PatternPrev, TemplateArgs, EarlySubstitution,
+        /*FindingInstantiatedContext=*/false);
     if (!Prev) return nullptr;
     PrevDecl = cast<EnumDecl>(Prev);
   }
 
   EnumDecl *Enum =
       EnumDecl::Create(SemaRef.Context, Owner, D->getBeginLoc(),
                        D->getLocation(), D->getIdentifier(), PrevDecl,
                        D->isScoped(), D->isScopedUsingClassTag(), D->isFixed());
   if (D->isFixed()) {
     if (TypeSourceInfo *TI = D->getIntegerTypeSourceInfo()) {
       // If we have type source information for the underlying type, it means it
       // has been explicitly set by the user. Perform substitution on it before
       // moving on.
       SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
-      TypeSourceInfo *NewTI = SemaRef.SubstType(TI, TemplateArgs, UnderlyingLoc,
-                                                DeclarationName());
+      TypeSourceInfo *NewTI = SemaRef.SubstType(
+          TI, TemplateArgs, EarlySubstitution, UnderlyingLoc, DeclarationName(),
+          /*AllowDeducedTST=*/false);
       if (!NewTI || SemaRef.CheckEnumUnderlyingType(NewTI))
         Enum->setIntegerType(SemaRef.Context.IntTy);
       else
         Enum->setIntegerTypeSourceInfo(NewTI);
     } else {
       assert(!D->getIntegerType()->isDependentType()
              && "Dependent type without type source info");
       Enum->setIntegerType(D->getIntegerType());
     }
   }
 
-  SemaRef.InstantiateAttrs(TemplateArgs, D, Enum);
+  SemaRef.InstantiateAttrs(TemplateArgs, EarlySubstitution, D, Enum,
+                           /*LateAttrs=*/nullptr,
+                           /*OuterMostScope=*/nullptr);
 
   Enum->setInstantiationOfMemberEnum(D, TSK_ImplicitInstantiation);
   Enum->setAccess(D->getAccess());
   // Forward the mangling number from the template to the instantiated decl.
   SemaRef.Context.setManglingNumber(Enum, SemaRef.Context.getManglingNumber(D));
   // See if the old tag was defined along with a declarator.
   // If it did, mark the new tag as being associated with that declarator.
   if (DeclaratorDecl *DD = SemaRef.Context.getDeclaratorForUnnamedTagDecl(D))
     SemaRef.Context.addDeclaratorForUnnamedTagDecl(Enum, DD);
   // See if the old tag was defined along with a typedef.
   // If it did, mark the new tag as being associated with that typedef.
   if (TypedefNameDecl *TND = SemaRef.Context.getTypedefNameForUnnamedTagDecl(D))
     SemaRef.Context.addTypedefNameForUnnamedTagDecl(Enum, TND);
   if (SubstQualifier(D, Enum)) return nullptr;
   Owner->addDecl(Enum);
 
   EnumDecl *Def = D->getDefinition();
   if (Def && Def != D) {
     // If this is an out-of-line definition of an enum member template, check
     // that the underlying types match in the instantiation of both
     // declarations.
     if (TypeSourceInfo *TI = Def->getIntegerTypeSourceInfo()) {
       SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
       QualType DefnUnderlying =
-        SemaRef.SubstType(TI->getType(), TemplateArgs,
+          SemaRef.SubstType(TI->getType(), TemplateArgs, EarlySubstitution,
                             UnderlyingLoc, DeclarationName());
       SemaRef.CheckEnumRedeclaration(Def->getLocation(), Def->isScoped(),
                                      DefnUnderlying, /*IsFixed=*/true, Enum);
     }
   }
 
   // C++11 [temp.inst]p1: The implicit instantiation of a class template
   // specialization causes the implicit instantiation of the declarations, but
   // not the definitions of scoped member enumerations.
void TemplateDeclInstantiator::InstantiateEnumDefinition(
   for (auto *EC : Pattern->enumerators()) {
     // The specified value for the enumerator.
     ExprResult Value((Expr *)nullptr);
     if (Expr *UninstValue = EC->getInitExpr()) {
       // The enumerator's value expression is a constant expression.
       EnterExpressionEvaluationContext Unevaluated(
           SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
 
-      Value = SemaRef.SubstExpr(UninstValue, TemplateArgs);
+      Value = SemaRef.SubstExpr(UninstValue, TemplateArgs, EarlySubstitution);
     }
 
     // Drop the initial value and continue.
     bool isInvalid = false;
     if (Value.isInvalid()) {
       Value = nullptr;
       isInvalid = true;
     }
 
     EnumConstantDecl *EnumConst
       = SemaRef.CheckEnumConstant(Enum, LastEnumConst,
                                   EC->getLocation(), EC->getIdentifier(),
                                   Value.get());
 
     if (isInvalid) {
       if (EnumConst)
         EnumConst->setInvalidDecl();
       Enum->setInvalidDecl();
     }
 
     if (EnumConst) {
-      SemaRef.InstantiateAttrs(TemplateArgs, EC, EnumConst);
+      SemaRef.InstantiateAttrs(TemplateArgs, EarlySubstitution, EC, EnumConst,
+                               /*LateAttrs=*/nullptr,
+                               /*OuterMostScope=*/nullptr);
 
       EnumConst->setAccess(Enum->getAccess());
       Enum->addDecl(EnumConst);
       Enumerators.push_back(EnumConst);
       LastEnumConst = EnumConst;
 
       if (Pattern->getDeclContext()->isFunctionOrMethod() &&
           !Enum->isScoped()) {
Decl *TemplateDeclInstantiator::VisitClassTemplateDecl(ClassTemplateDecl *D) {
 
   CXXRecordDecl *Pattern = D->getTemplatedDecl();
 
   // Instantiate the qualifier.  We have to do this first in case
   // we're a friend declaration, because if we are then we need to put
   // the new declaration in the appropriate context.
   NestedNameSpecifierLoc QualifierLoc = Pattern->getQualifierLoc();
   if (QualifierLoc) {
-    QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
-                                                       TemplateArgs);
+    QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(
+        QualifierLoc, TemplateArgs, EarlySubstitution);
     if (!QualifierLoc)
       return nullptr;
   }
 
   CXXRecordDecl *PrevDecl = nullptr;
   ClassTemplateDecl *PrevClassTemplate = nullptr;
 
   if (!isFriend && getPreviousDeclForInstantiation(Pattern)) {
if (isFriend) {
     if (QualifierLoc) {
       CXXScopeSpec SS;
       SS.Adopt(QualifierLoc);
       DC = SemaRef.computeDeclContext(SS);
       if (!DC) return nullptr;
     } else {
       DC = SemaRef.FindInstantiatedContext(Pattern->getLocation(),
                                            Pattern->getDeclContext(),
-                                           TemplateArgs);
+                                           TemplateArgs, EarlySubstitution);
     }
 
     // Look for a previous declaration of the template in the owning
     // context.
     LookupResult R(SemaRef, Pattern->getDeclName(), Pattern->getLocation(),
                    Sema::LookupOrdinaryName,
                    SemaRef.forRedeclarationInCurContext());
     SemaRef.LookupQualifiedName(R, DC);
Decl *TemplateDeclInstantiator::VisitClassTemplateDecl(ClassTemplateDecl *D) {
   CXXRecordDecl *RecordInst = CXXRecordDecl::Create(
       SemaRef.Context, Pattern->getTagKind(), DC, Pattern->getBeginLoc(),
       Pattern->getLocation(), Pattern->getIdentifier(), PrevDecl,
       /*DelayTypeCreation=*/true);
 
   if (QualifierLoc)
     RecordInst->setQualifierInfo(QualifierLoc);
 
-  SemaRef.InstantiateAttrsForDecl(TemplateArgs, Pattern, RecordInst, LateAttrs,
-                                                              StartingScope);
+  SemaRef.InstantiateAttrsForDecl(TemplateArgs, EarlySubstitution, Pattern,
+                                  RecordInst, LateAttrs, StartingScope);
 
   ClassTemplateDecl *Inst
     = ClassTemplateDecl::Create(SemaRef.Context, DC, D->getLocation(),
                                 D->getIdentifier(), InstParams, RecordInst);
   assert(!(isFriend && Owner->isDependentContext()));
   Inst->setPreviousDecl(PrevClassTemplate);
 
   RecordInst->setDescribedClassTemplate(Inst);
TemplateDeclInstantiator::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
   }
 
   return InstTemplate;
 }
 
 Decl *TemplateDeclInstantiator::VisitCXXRecordDecl(CXXRecordDecl *D) {
   CXXRecordDecl *PrevDecl = nullptr;
   if (CXXRecordDecl *PatternPrev = getPreviousDeclForInstantiation(D)) {
-    NamedDecl *Prev = SemaRef.FindInstantiatedDecl(D->getLocation(),
-                                                   PatternPrev,
-                                                   TemplateArgs);
+    NamedDecl *Prev = SemaRef.FindInstantiatedDecl(
+        D->getLocation(), PatternPrev, TemplateArgs, EarlySubstitution,
+        /*FindingInstantiatedContext=*/false);
     if (!Prev) return nullptr;
     PrevDecl = cast<CXXRecordDecl>(Prev);
   }
 
   CXXRecordDecl *Record = nullptr;
   bool IsInjectedClassName = D->isInjectedClassName();
   if (D->isLambda())
     Record = CXXRecordDecl::CreateLambda(
         SemaRef.Context, Owner, D->getLambdaTypeInfo(), D->getLocation(),
         D->getLambdaDependencyKind(), D->isGenericLambda(),
         D->getLambdaCaptureDefault());
   else
     Record = CXXRecordDecl::Create(SemaRef.Context, D->getTagKind(), Owner,
                                    D->getBeginLoc(), D->getLocation(),
                                    D->getIdentifier(), PrevDecl,
                                    /*DelayTypeCreation=*/IsInjectedClassName);
   // Link the type of the injected-class-name to that of the outer class.
   if (IsInjectedClassName)
     (void)SemaRef.Context.getTypeDeclType(Record, cast<CXXRecordDecl>(Owner));
 
   // Substitute the nested name specifier, if any.
   if (SubstQualifier(D, Record))
     return nullptr;
 
-  SemaRef.InstantiateAttrsForDecl(TemplateArgs, D, Record, LateAttrs,
-                                                              StartingScope);
+  SemaRef.InstantiateAttrsForDecl(TemplateArgs, EarlySubstitution, D, Record,
+                                  LateAttrs, StartingScope);
 
   Record->setImplicit(D->isImplicit());
   // FIXME: Check against AS_none is an ugly hack to work around the issue that
   // the tag decls introduced by friend class declarations don't have an access
   // specifier. Remove once this area of the code gets sorted out.
   if (D->getAccess() != AS_none)
     Record->setAccess(D->getAccess());
   if (!IsInjectedClassName)
Decl *TemplateDeclInstantiator::VisitCXXRecordDecl(CXXRecordDecl *D) {
   Owner->addDecl(Record);
 
   // DR1484 clarifies that the members of a local class are instantiated as part
   // of the instantiation of their enclosing entity.
   if (D->isCompleteDefinition() && D->isLocalClass()) {
     Sema::LocalEagerInstantiationScope LocalInstantiations(SemaRef);
 
     SemaRef.InstantiateClass(D->getLocation(), Record, D, TemplateArgs,
-                             TSK_ImplicitInstantiation,
+                             EarlySubstitution, TSK_ImplicitInstantiation,
                              /*Complain=*/true);
 
     // For nested local classes, we will instantiate the members when we
     // reach the end of the outermost (non-nested) local class.
     if (!D->isCXXClassMember())
       SemaRef.InstantiateClassMembers(D->getLocation(), Record, TemplateArgs,
+                                      EarlySubstitution,
                                       TSK_ImplicitInstantiation);
 
     // This class may have local implicit instantiations that need to be
     // performed within this scope.
     LocalInstantiations.perform();
   }
 
   SemaRef.DiagnoseUnusedNestedTypedefs(Record);
Decl *TemplateDeclInstantiator::VisitFunctionDecl(
   bool MergeWithParentScope = (TemplateParams != nullptr) ||
     Owner->isFunctionOrMethod() ||
     !(isa<Decl>(Owner) &&
       cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
   LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
 
   ExplicitSpecifier InstantiatedExplicitSpecifier;
   if (auto *DGuide = dyn_cast<CXXDeductionGuideDecl>(D)) {
-    InstantiatedExplicitSpecifier = instantiateExplicitSpecifier(
-        SemaRef, TemplateArgs, DGuide->getExplicitSpecifier(), DGuide);
+    InstantiatedExplicitSpecifier =
+        instantiateExplicitSpecifier(SemaRef, TemplateArgs, EarlySubstitution,
+                                     DGuide->getExplicitSpecifier(), DGuide);
     if (InstantiatedExplicitSpecifier.isInvalid())
       return nullptr;
   }
 
   SmallVector<ParmVarDecl *, 4> Params;
   TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
   if (!TInfo)
     return nullptr;
if (LastParam && LastParam->isImplicit() &&
           SemaRef.Context, TemplateParams->getTemplateLoc(),
           TemplateParams->getLAngleLoc(), TemplateParams->asArray(),
           TemplateParams->getRAngleLoc(), TemplateParams->getRequiresClause());
     }
   }
 
   NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
   if (QualifierLoc) {
-    QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
-                                                       TemplateArgs);
+    QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(
+        QualifierLoc, TemplateArgs, EarlySubstitution);
     if (!QualifierLoc)
       return nullptr;
   }
 
   // FIXME: Concepts: Do not substitute into constraint expressions
   Expr *TrailingRequiresClause = D->getTrailingRequiresClause();
   if (TrailingRequiresClause) {
     EnterExpressionEvaluationContext ConstantEvaluated(
         SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
-    ExprResult SubstRC = SemaRef.SubstExpr(TrailingRequiresClause,
-                                           TemplateArgs);
+    ExprResult SubstRC = SemaRef.SubstExpr(TrailingRequiresClause, TemplateArgs,
+                                           EarlySubstitution);
     if (SubstRC.isInvalid())
       return nullptr;
     TrailingRequiresClause = SubstRC.get();
     if (!SemaRef.CheckConstraintExpression(TrailingRequiresClause))
       return nullptr;
   }
 
   // If we're instantiating a local function declaration, put the result
   // in the enclosing namespace; otherwise we need to find the instantiated
   // context.
   DeclContext *DC;
   if (D->isLocalExternDecl()) {
     DC = Owner;
     SemaRef.adjustContextForLocalExternDecl(DC);
   } else if (isFriend && QualifierLoc) {
     CXXScopeSpec SS;
     SS.Adopt(QualifierLoc);
     DC = SemaRef.computeDeclContext(SS);
     if (!DC) return nullptr;
   } else {
     DC = SemaRef.FindInstantiatedContext(D->getLocation(), D->getDeclContext(),
-                                         TemplateArgs);
+                                         TemplateArgs, EarlySubstitution);
   }
 
-  DeclarationNameInfo NameInfo
-    = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
+  DeclarationNameInfo NameInfo = SemaRef.SubstDeclarationNameInfo(
+      D->getNameInfo(), TemplateArgs, EarlySubstitution);
 
   if (FunctionRewriteKind != RewriteKind::None)
     adjustForRewrite(FunctionRewriteKind, D, T, TInfo, NameInfo);
 
   FunctionDecl *Function;
   if (auto *DGuide = dyn_cast<CXXDeductionGuideDecl>(D)) {
     Function = CXXDeductionGuideDecl::Create(
         SemaRef.Context, DC, D->getInnerLocStart(),
Decl *TemplateDeclInstantiator::VisitFunctionDecl(
   if (DependentFunctionTemplateSpecializationInfo *Info
         = D->getDependentSpecializationInfo()) {
     assert(isFriend && "non-friend has dependent specialization info?");
 
     // Instantiate the explicit template arguments.
     TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
                                           Info->getRAngleLoc());
     if (SemaRef.SubstTemplateArguments(Info->arguments(), TemplateArgs,
-                                       ExplicitArgs))
+                                       EarlySubstitution, ExplicitArgs))
       return nullptr;
 
     // Map the candidate templates to their instantiations.
     for (unsigned I = 0, E = Info->getNumTemplates(); I != E; ++I) {
-      Decl *Temp = SemaRef.FindInstantiatedDecl(D->getLocation(),
-                                                Info->getTemplate(I),
-                                                TemplateArgs);
+      Decl *Temp =
+          SemaRef.FindInstantiatedDecl(D->getLocation(), Info->getTemplate(I),
+                                       TemplateArgs, EarlySubstitution,
+                                       /*FindingInstantiatedContext=*/false);
       if (!Temp) return nullptr;
 
       Previous.addDecl(cast<FunctionTemplateDecl>(Temp));
     }
 
     if (SemaRef.CheckFunctionTemplateSpecialization(Function,
                                                     &ExplicitArgs,
                                                     Previous))
       Function->setInvalidDecl();
 
     IsExplicitSpecialization = true;
   } else if (const ASTTemplateArgumentListInfo *Info =
                  D->getTemplateSpecializationArgsAsWritten()) {
     // The name of this function was written as a template-id.
     SemaRef.LookupQualifiedName(Previous, DC);
 
     // Instantiate the explicit template arguments.
     TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
                                           Info->getRAngleLoc());
     if (SemaRef.SubstTemplateArguments(Info->arguments(), TemplateArgs,
-                                       ExplicitArgs))
+                                       EarlySubstitution, ExplicitArgs))
       return nullptr;
 
     if (SemaRef.CheckFunctionTemplateSpecialization(Function,
                                                     &ExplicitArgs,
                                                     Previous))
       Function->setInvalidDecl();
 
     IsExplicitSpecialization = true;
for (unsigned I = 0; I != NumTempParamLists; ++I) {
       TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
       if (!InstParams)
         return nullptr;
       TempParamLists[I] = InstParams;
     }
   }
 
   ExplicitSpecifier InstantiatedExplicitSpecifier =
-      instantiateExplicitSpecifier(SemaRef, TemplateArgs,
+      instantiateExplicitSpecifier(SemaRef, TemplateArgs, EarlySubstitution,
                                    ExplicitSpecifier::getFromDecl(D), D);
   if (InstantiatedExplicitSpecifier.isInvalid())
     return nullptr;
 
   // Implicit destructors/constructors created for local classes in
   // DeclareImplicit* (see SemaDeclCXX.cpp) might not have an associated TSI.
   // Unfortunately there isn't enough context in those functions to
   // conditionally populate the TSI without breaking non-template related use
if (LastParam && LastParam->isImplicit() &&
           SemaRef.Context, TemplateParams->getTemplateLoc(),
           TemplateParams->getLAngleLoc(), TemplateParams->asArray(),
           TemplateParams->getRAngleLoc(), TemplateParams->getRequiresClause());
     }
   }
 
   NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
   if (QualifierLoc) {
-    QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc,
-                                                 TemplateArgs);
+    QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(
+        QualifierLoc, TemplateArgs, EarlySubstitution);
     if (!QualifierLoc)
       return nullptr;
   }
 
   // FIXME: Concepts: Do not substitute into constraint expressions
   Expr *TrailingRequiresClause = D->getTrailingRequiresClause();
   if (TrailingRequiresClause) {
     EnterExpressionEvaluationContext ConstantEvaluated(
         SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
     auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(Owner);
     Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext,
                                      D->getMethodQualifiers(), ThisContext);
-    ExprResult SubstRC = SemaRef.SubstExpr(TrailingRequiresClause,
-                                           TemplateArgs);
+    ExprResult SubstRC = SemaRef.SubstExpr(TrailingRequiresClause, TemplateArgs,
+                                           EarlySubstitution);
     if (SubstRC.isInvalid())
       return nullptr;
     TrailingRequiresClause = SubstRC.get();
     if (!SemaRef.CheckConstraintExpression(TrailingRequiresClause))
       return nullptr;
   }
 
   DeclContext *DC = Owner;
   if (isFriend) {
     if (QualifierLoc) {
       CXXScopeSpec SS;
       SS.Adopt(QualifierLoc);
       DC = SemaRef.computeDeclContext(SS);
 
       if (DC && SemaRef.RequireCompleteDeclContext(SS, DC))
         return nullptr;
     } else {
-      DC = SemaRef.FindInstantiatedContext(D->getLocation(),
-                                           D->getDeclContext(),
-                                           TemplateArgs);
+      DC =
+          SemaRef.FindInstantiatedContext(D->getLocation(), D->getDeclContext(),
+                                          TemplateArgs, EarlySubstitution);
     }
     if (!DC) return nullptr;
   }
 
-  DeclarationNameInfo NameInfo
-    = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
+  DeclarationNameInfo NameInfo = SemaRef.SubstDeclarationNameInfo(
+      D->getNameInfo(), TemplateArgs, EarlySubstitution);
 
   if (FunctionRewriteKind != RewriteKind::None)
     adjustForRewrite(FunctionRewriteKind, D, T, TInfo, NameInfo);
 
   // Build the instantiated method declaration.
   CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
   CXXMethodDecl *Method = nullptr;
 
Decl *TemplateDeclInstantiator::VisitCXXMethodDecl(
   if (DependentFunctionTemplateSpecializationInfo *Info
         = D->getDependentSpecializationInfo()) {
     assert(isFriend && "non-friend has dependent specialization info?");
 
     // Instantiate the explicit template arguments.
     TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
                                           Info->getRAngleLoc());
     if (SemaRef.SubstTemplateArguments(Info->arguments(), TemplateArgs,
-                                       ExplicitArgs))
+                                       EarlySubstitution, ExplicitArgs))
       return nullptr;
 
     // Map the candidate templates to their instantiations.
     for (unsigned I = 0, E = Info->getNumTemplates(); I != E; ++I) {
-      Decl *Temp = SemaRef.FindInstantiatedDecl(D->getLocation(),
-                                                Info->getTemplate(I),
-                                                TemplateArgs);
+      Decl *Temp =
+          SemaRef.FindInstantiatedDecl(D->getLocation(), Info->getTemplate(I),
+                                       TemplateArgs, EarlySubstitution,
+                                       /*FindingInstantiatedContext=*/false);
       if (!Temp) return nullptr;
 
       Previous.addDecl(cast<FunctionTemplateDecl>(Temp));
     }
 
     if (SemaRef.CheckFunctionTemplateSpecialization(Method,
                                                     &ExplicitArgs,
                                                     Previous))
       Method->setInvalidDecl();
 
     IsExplicitSpecialization = true;
   } else if (const ASTTemplateArgumentListInfo *Info =
                  ClassScopeSpecializationArgs.getValueOr(
                      D->getTemplateSpecializationArgsAsWritten())) {
     SemaRef.LookupQualifiedName(Previous, DC);
 
     TemplateArgumentListInfo ExplicitArgs(Info->getLAngleLoc(),
                                           Info->getRAngleLoc());
     if (SemaRef.SubstTemplateArguments(Info->arguments(), TemplateArgs,
-                                       ExplicitArgs))
+                                       EarlySubstitution, ExplicitArgs))
       return nullptr;
 
     if (SemaRef.CheckFunctionTemplateSpecialization(Method,
                                                     &ExplicitArgs,
                                                     Previous))
       Method->setInvalidDecl();
 
     IsExplicitSpecialization = true;
Decl *TemplateDeclInstantiator::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
   return VisitCXXMethodDecl(D);
 }
 
 Decl *TemplateDeclInstantiator::VisitCXXConversionDecl(CXXConversionDecl *D) {
   return VisitCXXMethodDecl(D);
 }
 
 Decl *TemplateDeclInstantiator::VisitParmVarDecl(ParmVarDecl *D) {
-  return SemaRef.SubstParmVarDecl(D, TemplateArgs, /*indexAdjustment*/ 0, None,
-                                  /*ExpectParameterPack=*/ false);
+  return SemaRef.SubstParmVarDecl(D, TemplateArgs, EarlySubstitution,
+                                  /*indexAdjustment*/ 0, None,
+                                  /*ExpectParameterPack=*/false);
 }
 
 Decl *TemplateDeclInstantiator::VisitTemplateTypeParmDecl(
                                                     TemplateTypeParmDecl *D) {
   assert(D->getTypeForDecl()->isTemplateTypeParmType());
 
   Optional<unsigned> NumExpanded;
 
if (D->isPackExpansion() && !D->isExpandedParameterPack()) {
                           TC->getConceptNameInfo().getEndLoc()),
               Unexpanded, TemplateArgs, Expand, RetainExpansion, NumExpanded))
         return nullptr;
     }
   }
 
   TemplateTypeParmDecl *Inst = TemplateTypeParmDecl::Create(
       SemaRef.Context, Owner, D->getBeginLoc(), D->getLocation(),
-      D->getDepth() - TemplateArgs.getNumSubstitutedLevels(), D->getIndex(),
-      D->getIdentifier(), D->wasDeclaredWithTypename(), D->isParameterPack(),
+      getNewDepth(D->getDepth()), D->getIndex(), D->getIdentifier(),
+      D->wasDeclaredWithTypename(), D->isParameterPack(),
       D->hasTypeConstraint(), NumExpanded);
 
   Inst->setAccess(AS_public);
   Inst->setImplicit(D->isImplicit());
   if (auto *TC = D->getTypeConstraint()) {
     if (!D->isImplicit()) {
       // Invented template parameter type constraints will be instantiated with
       // the corresponding auto-typed parameter as it might reference other
       // parameters.
 
       // TODO: Concepts: do not instantiate the constraint (delayed constraint
       // substitution)
-      if (SemaRef.SubstTypeConstraint(Inst, TC, TemplateArgs))
+      if (SemaRef.SubstTypeConstraint(Inst, TC, TemplateArgs,
+                                      EarlySubstitution))
         return nullptr;
     }
   }
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
-    TypeSourceInfo *InstantiatedDefaultArg =
-        SemaRef.SubstType(D->getDefaultArgumentInfo(), TemplateArgs,
-                          D->getDefaultArgumentLoc(), D->getDeclName());
+    TypeSourceInfo *InstantiatedDefaultArg = SemaRef.SubstType(
+        D->getDefaultArgumentInfo(), TemplateArgs, EarlySubstitution,
+        D->getDefaultArgumentLoc(), D->getDeclName(),
+        /*AllowDeducedTST=*/false);
     if (InstantiatedDefaultArg)
       Inst->setDefaultArgument(InstantiatedDefaultArg);
   }
 
   // Introduce this template parameter's instantiation into the instantiation
   // scope.
   SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Inst);
 
Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl(
   bool Invalid = false;
 
   if (D->isExpandedParameterPack()) {
     // The non-type template parameter pack is an already-expanded pack
     // expansion of types. Substitute into each of the expanded types.
     ExpandedParameterPackTypes.reserve(D->getNumExpansionTypes());
     ExpandedParameterPackTypesAsWritten.reserve(D->getNumExpansionTypes());
     for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
-      TypeSourceInfo *NewDI =
-          SemaRef.SubstType(D->getExpansionTypeSourceInfo(I), TemplateArgs,
-                            D->getLocation(), D->getDeclName());
+      TypeSourceInfo *NewDI = SemaRef.SubstType(
+          D->getExpansionTypeSourceInfo(I), TemplateArgs, EarlySubstitution,
+          D->getLocation(), D->getDeclName(),
+          /*AllowDeducedTST=*/false);
       if (!NewDI)
         return nullptr;
 
       QualType NewT =
           SemaRef.CheckNonTypeTemplateParameterType(NewDI, D->getLocation());
       if (NewT.isNull())
         return nullptr;
 
if (SemaRef.CheckParameterPacksForExpansion(Expansion.getEllipsisLoc(),
                                                 TemplateArgs,
                                                 Expand, RetainExpansion,
                                                 NumExpansions))
       return nullptr;
 
     if (Expand) {
       for (unsigned I = 0; I != *NumExpansions; ++I) {
         Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
-        TypeSourceInfo *NewDI = SemaRef.SubstType(Pattern, TemplateArgs,
-                                                  D->getLocation(),
-                                                  D->getDeclName());
+        TypeSourceInfo *NewDI =
+            SemaRef.SubstType(Pattern, TemplateArgs, EarlySubstitution,
+                              D->getLocation(), D->getDeclName());
         if (!NewDI)
           return nullptr;
 
         QualType NewT =
             SemaRef.CheckNonTypeTemplateParameterType(NewDI, D->getLocation());
         if (NewT.isNull())
           return nullptr;
 
         ExpandedParameterPackTypesAsWritten.push_back(NewDI);
         ExpandedParameterPackTypes.push_back(NewT);
       }
 
       // Note that we have an expanded parameter pack. The "type" of this
       // expanded parameter pack is the original expansion type, but callers
       // will end up using the expanded parameter pack types for type-checking.
       IsExpandedParameterPack = true;
       DI = D->getTypeSourceInfo();
       T = DI->getType();
     } else {
       // We cannot fully expand the pack expansion now, so substitute into the
       // pattern and create a new pack expansion type.
       Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
-      TypeSourceInfo *NewPattern = SemaRef.SubstType(Pattern, TemplateArgs,
-                                                     D->getLocation(),
-                                                     D->getDeclName());
+      TypeSourceInfo *NewPattern =
+          SemaRef.SubstType(Pattern, TemplateArgs, EarlySubstitution,
+                            D->getLocation(), D->getDeclName());
       if (!NewPattern)
         return nullptr;
 
       SemaRef.CheckNonTypeTemplateParameterType(NewPattern, D->getLocation());
       DI = SemaRef.CheckPackExpansion(NewPattern, Expansion.getEllipsisLoc(),
                                       NumExpansions);
       if (!DI)
         return nullptr;
 
       T = DI->getType();
     }
   } else {
     // Simple case: substitution into a parameter that is not a parameter pack.
-    DI = SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
-                           D->getLocation(), D->getDeclName());
+    DI =
+        SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
+                          EarlySubstitution, D->getLocation(), D->getDeclName(),
+                          /*AllowDeducedTST=*/false);
     if (!DI)
       return nullptr;
 
     // Check that this type is acceptable for a non-type template parameter.
     T = SemaRef.CheckNonTypeTemplateParameterType(DI, D->getLocation());
     if (T.isNull()) {
       T = SemaRef.Context.IntTy;
       Invalid = true;
     }
   }
 
   NonTypeTemplateParmDecl *Param;
   if (IsExpandedParameterPack)
     Param = NonTypeTemplateParmDecl::Create(
         SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
-        D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
-        D->getPosition(), D->getIdentifier(), T, DI, ExpandedParameterPackTypes,
-        ExpandedParameterPackTypesAsWritten);
+        getNewDepth(D->getDepth()), D->getPosition(), D->getIdentifier(), T, DI,
+        ExpandedParameterPackTypes, ExpandedParameterPackTypesAsWritten);
   else
     Param = NonTypeTemplateParmDecl::Create(
         SemaRef.Context, Owner, D->getInnerLocStart(), D->getLocation(),
-        D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
-        D->getPosition(), D->getIdentifier(), T, D->isParameterPack(), DI);
+        getNewDepth(D->getDepth()), D->getPosition(), D->getIdentifier(), T,
+        D->isParameterPack(), DI);
 
   if (AutoTypeLoc AutoLoc = DI->getTypeLoc().getContainedAutoTypeLoc())
     if (AutoLoc.isConstrained())
       if (SemaRef.AttachTypeConstraint(
               AutoLoc, Param,
               IsExpandedParameterPack
                 ? DI->getTypeLoc().getAs<PackExpansionTypeLoc>()
                     .getEllipsisLoc()
                 : SourceLocation()))
         Invalid = true;
 
   Param->setAccess(AS_public);
   Param->setImplicit(D->isImplicit());
   if (Invalid)
     Param->setInvalidDecl();
 
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
     EnterExpressionEvaluationContext ConstantEvaluated(
         SemaRef, Sema::ExpressionEvaluationContext::ConstantEvaluated);
-    ExprResult Value = SemaRef.SubstExpr(D->getDefaultArgument(), TemplateArgs);
+    ExprResult Value = SemaRef.SubstExpr(D->getDefaultArgument(), TemplateArgs,
+                                         EarlySubstitution);
     if (!Value.isInvalid())
       Param->setDefaultArgument(Value.get());
   }
 
   // Introduce this template parameter's instantiation into the instantiation
   // scope.
   SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);
   return Param;
if (D->isExpandedParameterPack()) {
     if (!InstParams)
       return nullptr;
   }
 
   // Build the template template parameter.
   TemplateTemplateParmDecl *Param;
   if (IsExpandedParameterPack)
     Param = TemplateTemplateParmDecl::Create(
-        SemaRef.Context, Owner, D->getLocation(),
-        D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
+        SemaRef.Context, Owner, D->getLocation(), getNewDepth(D->getDepth()),
         D->getPosition(), D->getIdentifier(), InstParams, ExpandedParams);
   else
     Param = TemplateTemplateParmDecl::Create(
-        SemaRef.Context, Owner, D->getLocation(),
-        D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
+        SemaRef.Context, Owner, D->getLocation(), getNewDepth(D->getDepth()),
         D->getPosition(), D->isParameterPack(), D->getIdentifier(), InstParams);
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
     NestedNameSpecifierLoc QualifierLoc =
         D->getDefaultArgument().getTemplateQualifierLoc();
-    QualifierLoc =
-        SemaRef.SubstNestedNameSpecifierLoc(QualifierLoc, TemplateArgs);
+    QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(
+        QualifierLoc, TemplateArgs, EarlySubstitution);
     TemplateName TName = SemaRef.SubstTemplateName(
         QualifierLoc, D->getDefaultArgument().getArgument().getAsTemplate(),
-        D->getDefaultArgument().getTemplateNameLoc(), TemplateArgs);
+        D->getDefaultArgument().getTemplateNameLoc(), TemplateArgs,
+        EarlySubstitution);
     if (!TName.isNull())
       Param->setDefaultArgument(
           SemaRef.Context,
           TemplateArgumentLoc(SemaRef.Context, TemplateArgument(TName),
                               D->getDefaultArgument().getTemplateQualifierLoc(),
                               D->getDefaultArgument().getTemplateNameLoc()));
   }
   Param->setAccess(AS_public);
for (auto *Shadow : D->shadows()) {
 
     NamedDecl *InstTarget = nullptr;
     if (auto *EmptyD =
             dyn_cast<UnresolvedUsingIfExistsDecl>(Shadow->getTargetDecl())) {
       InstTarget = UnresolvedUsingIfExistsDecl::Create(
           SemaRef.Context, Owner, EmptyD->getLocation(), EmptyD->getDeclName());
     } else {
       InstTarget = cast_or_null<NamedDecl>(SemaRef.FindInstantiatedDecl(
-          Shadow->getLocation(), OldTarget, TemplateArgs));
+          Shadow->getLocation(), OldTarget, TemplateArgs, EarlySubstitution,
+          /*FindingInstantiatedContext=*/false));
     }
     if (!InstTarget)
       return nullptr;
 
     UsingShadowDecl *PrevDecl = nullptr;
     if (Lookup &&
         SemaRef.CheckUsingShadowDecl(Inst, InstTarget, *Lookup, PrevDecl))
       continue;
 
     if (UsingShadowDecl *OldPrev = getPreviousDeclForInstantiation(Shadow))
       PrevDecl = cast_or_null<UsingShadowDecl>(SemaRef.FindInstantiatedDecl(
-          Shadow->getLocation(), OldPrev, TemplateArgs));
+          Shadow->getLocation(), OldPrev, TemplateArgs, EarlySubstitution,
+          /*FindingInstantiatedContext=*/false));
 
     UsingShadowDecl *InstShadow = SemaRef.BuildUsingShadowDecl(
         /*Scope*/ nullptr, Inst, InstTarget, PrevDecl);
     SemaRef.Context.setInstantiatedFromUsingShadowDecl(InstShadow, Shadow);
 
     if (isFunctionScope)
       SemaRef.CurrentInstantiationScope->InstantiatedLocal(Shadow, InstShadow);
   }
 
   return Inst;
 }
 
 Decl *TemplateDeclInstantiator::VisitUsingDecl(UsingDecl *D) {
 
   // The nested name specifier may be dependent, for example
   //     template <typename T> struct t {
   //       struct s1 { T f1(); };
   //       struct s2 : s1 { using s1::f1; };
   //     };
   //     template struct t<int>;
   // Here, in using s1::f1, s1 refers to t<T>::s1;
   // we need to substitute for t<int>::s1.
-  NestedNameSpecifierLoc QualifierLoc
-    = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
-                                          TemplateArgs);
+  NestedNameSpecifierLoc QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(
+      D->getQualifierLoc(), TemplateArgs, EarlySubstitution);
   if (!QualifierLoc)
     return nullptr;
 
   // For an inheriting constructor declaration, the name of the using
   // declaration is the name of a constructor in this class, not in the
   // base class.
   DeclarationNameInfo NameInfo = D->getNameInfo();
   if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName)
if (NameInfo.getName().getNameKind() == DeclarationName::CXXConstructorName)
     SemaRef.CheckInheritingConstructorUsingDecl(NewUD);
 
   return VisitBaseUsingDecls(D, NewUD, CheckRedeclaration ? &Prev : nullptr);
 }
 
 Decl *TemplateDeclInstantiator::VisitUsingEnumDecl(UsingEnumDecl *D) {
   // Cannot be a dependent type, but still could be an instantiation
   EnumDecl *EnumD = cast_or_null<EnumDecl>(SemaRef.FindInstantiatedDecl(
-      D->getLocation(), D->getEnumDecl(), TemplateArgs));
+      D->getLocation(), D->getEnumDecl(), TemplateArgs, EarlySubstitution,
+      /*FindingInstantiatedContext=*/false));
 
   if (SemaRef.RequireCompleteEnumDecl(EnumD, EnumD->getLocation()))
     return nullptr;
 
   UsingEnumDecl *NewUD =
       UsingEnumDecl::Create(SemaRef.Context, Owner, D->getUsingLoc(),
                             D->getEnumLoc(), D->getLocation(), EnumD);
 
if (D->isPackExpansion() && !InstantiatingPackElement) {
     if (isDeclWithinFunction(D))
       SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewD);
     return NewD;
   }
 
   UnresolvedUsingTypenameDecl *TD = dyn_cast<UnresolvedUsingTypenameDecl>(D);
   SourceLocation TypenameLoc = TD ? TD->getTypenameLoc() : SourceLocation();
 
-  NestedNameSpecifierLoc QualifierLoc
-    = SemaRef.SubstNestedNameSpecifierLoc(D->getQualifierLoc(),
-                                          TemplateArgs);
+  NestedNameSpecifierLoc QualifierLoc = SemaRef.SubstNestedNameSpecifierLoc(
+      D->getQualifierLoc(), TemplateArgs, EarlySubstitution);
   if (!QualifierLoc)
     return nullptr;
 
   CXXScopeSpec SS;
   SS.Adopt(QualifierLoc);
 
-  DeclarationNameInfo NameInfo
-    = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
+  DeclarationNameInfo NameInfo = SemaRef.SubstDeclarationNameInfo(
+      D->getNameInfo(), TemplateArgs, EarlySubstitution);
 
   // Produce a pack expansion only if we're not instantiating a particular
   // slice of a pack expansion.
   bool InstantiatingSlice = D->getEllipsisLoc().isValid() &&
                             SemaRef.ArgumentPackSubstitutionIndex != -1;
   SourceLocation EllipsisLoc =
       InstantiatingSlice ? SourceLocation() : D->getEllipsisLoc();
 
   bool IsUsingIfExists = D->template hasAttr<UsingIfExistsAttr>();
   NamedDecl *UD = SemaRef.BuildUsingDeclaration(
       /*Scope*/ nullptr, D->getAccess(), D->getUsingLoc(),
       /*HasTypename*/ TD, TypenameLoc, SS, NameInfo, EllipsisLoc,
       ParsedAttributesView(),
       /*IsInstantiation*/ true, IsUsingIfExists);
   if (UD) {
-    SemaRef.InstantiateAttrs(TemplateArgs, D, UD);
+    SemaRef.InstantiateAttrs(TemplateArgs, EarlySubstitution, D, UD,
+                             /*LateAttrs=*/nullptr,
+                             /*OuterMostScope=*/nullptr);
     SemaRef.Context.setInstantiatedFromUsingDecl(UD, D);
   }
 
   return UD;
 }
 
 Decl *TemplateDeclInstantiator::VisitUnresolvedUsingTypenameDecl(
     UnresolvedUsingTypenameDecl *D) {
   return instantiateUnresolvedUsingDecl(D);
 }
 
 Decl *TemplateDeclInstantiator::VisitUnresolvedUsingValueDecl(
     UnresolvedUsingValueDecl *D) {
   return instantiateUnresolvedUsingDecl(D);
 }
 
 Decl *TemplateDeclInstantiator::VisitUnresolvedUsingIfExistsDecl(
     UnresolvedUsingIfExistsDecl *D) {
   llvm_unreachable("referring to unresolved decl out of UsingShadowDecl");
 }
 
 Decl *TemplateDeclInstantiator::VisitUsingPackDecl(UsingPackDecl *D) {
   SmallVector<NamedDecl*, 8> Expansions;
   for (auto *UD : D->expansions()) {
-    if (NamedDecl *NewUD =
-            SemaRef.FindInstantiatedDecl(D->getLocation(), UD, TemplateArgs))
+    if (NamedDecl *NewUD = SemaRef.FindInstantiatedDecl(
+            D->getLocation(), UD, TemplateArgs, EarlySubstitution,
+            /*FindingInstantiatedContext=*/false))
       Expansions.push_back(NewUD);
     else
       return nullptr;
   }
 
   auto *NewD = SemaRef.BuildUsingPackDecl(D, Expansions);
   if (isDeclWithinFunction(D))
     SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, NewD);
   return NewD;
 }
 
 Decl *TemplateDeclInstantiator::VisitClassScopeFunctionSpecializationDecl(
     ClassScopeFunctionSpecializationDecl *Decl) {
   CXXMethodDecl *OldFD = Decl->getSpecialization();
   return cast_or_null<CXXMethodDecl>(
       VisitCXXMethodDecl(OldFD, nullptr, Decl->getTemplateArgsAsWritten()));
 }
 
 Decl *TemplateDeclInstantiator::VisitOMPThreadPrivateDecl(
                                      OMPThreadPrivateDecl *D) {
   SmallVector<Expr *, 5> Vars;
   for (auto *I : D->varlists()) {
-    Expr *Var = SemaRef.SubstExpr(I, TemplateArgs).get();
+    Expr *Var = SemaRef.SubstExpr(I, TemplateArgs, EarlySubstitution).get();
     assert(isa<DeclRefExpr>(Var) && "threadprivate arg is not a DeclRefExpr");
     Vars.push_back(Var);
   }
 
   OMPThreadPrivateDecl *TD =
     SemaRef.CheckOMPThreadPrivateDecl(D->getLocation(), Vars);
 
   TD->setAccess(AS_public);
   Owner->addDecl(TD);
 
   return TD;
 }
 
 Decl *TemplateDeclInstantiator::VisitOMPAllocateDecl(OMPAllocateDecl *D) {
   SmallVector<Expr *, 5> Vars;
   for (auto *I : D->varlists()) {
-    Expr *Var = SemaRef.SubstExpr(I, TemplateArgs).get();
+    Expr *Var = SemaRef.SubstExpr(I, TemplateArgs, EarlySubstitution).get();
     assert(isa<DeclRefExpr>(Var) && "allocate arg is not a DeclRefExpr");
     Vars.push_back(Var);
   }
   SmallVector<OMPClause *, 4> Clauses;
   // Copy map clauses from the original mapper.
   for (OMPClause *C : D->clauselists()) {
     OMPClause *IC = nullptr;
     if (auto *AC = dyn_cast<OMPAllocatorClause>(C)) {
-      ExprResult NewE = SemaRef.SubstExpr(AC->getAllocator(), TemplateArgs);
+      ExprResult NewE = SemaRef.SubstExpr(AC->getAllocator(), TemplateArgs,
+                                          EarlySubstitution);
       if (!NewE.isUsable())
         continue;
       IC = SemaRef.ActOnOpenMPAllocatorClause(
           NewE.get(), AC->getBeginLoc(), AC->getLParenLoc(), AC->getEndLoc());
     } else if (auto *AC = dyn_cast<OMPAlignClause>(C)) {
-      ExprResult NewE = SemaRef.SubstExpr(AC->getAlignment(), TemplateArgs);
+      ExprResult NewE = SemaRef.SubstExpr(AC->getAlignment(), TemplateArgs,
+                                          EarlySubstitution);
       if (!NewE.isUsable())
         continue;
       IC = SemaRef.ActOnOpenMPAlignClause(NewE.get(), AC->getBeginLoc(),
                                           AC->getLParenLoc(), AC->getEndLoc());
       // If align clause value ends up being invalid, this can end up null.
       if (!IC)
         continue;
     }
Decl *TemplateDeclInstantiator::VisitOMPDeclareReductionDecl(
   // Instantiate type and check if it is allowed.
   const bool RequiresInstantiation =
       D->getType()->isDependentType() ||
       D->getType()->isInstantiationDependentType() ||
       D->getType()->containsUnexpandedParameterPack();
   QualType SubstReductionType;
   if (RequiresInstantiation) {
     SubstReductionType = SemaRef.ActOnOpenMPDeclareReductionType(
-        D->getLocation(),
-        ParsedType::make(SemaRef.SubstType(
-            D->getType(), TemplateArgs, D->getLocation(), DeclarationName())));
+        D->getLocation(), ParsedType::make(SemaRef.SubstType(
+                              D->getType(), TemplateArgs, EarlySubstitution,
+                              D->getLocation(), DeclarationName())));
   } else {
     SubstReductionType = D->getType();
   }
   if (SubstReductionType.isNull())
     return nullptr;
   Expr *Combiner = D->getCombiner();
   Expr *Init = D->getInitializer();
   bool IsCorrect = true;
SemaRef.CurrentInstantiationScope->InstantiatedLocal(
         cast<DeclRefExpr>(D->getCombinerIn())->getDecl(),
         cast<DeclRefExpr>(NewDRD->getCombinerIn())->getDecl());
     SemaRef.CurrentInstantiationScope->InstantiatedLocal(
         cast<DeclRefExpr>(D->getCombinerOut())->getDecl(),
         cast<DeclRefExpr>(NewDRD->getCombinerOut())->getDecl());
     auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(Owner);
     Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, Qualifiers(),
                                      ThisContext);
-    SubstCombiner = SemaRef.SubstExpr(Combiner, TemplateArgs).get();
+    SubstCombiner =
+        SemaRef.SubstExpr(Combiner, TemplateArgs, EarlySubstitution).get();
     SemaRef.ActOnOpenMPDeclareReductionCombinerEnd(NewDRD, SubstCombiner);
   }
   // Initializers instantiation sequence.
   if (Init) {
     VarDecl *OmpPrivParm = SemaRef.ActOnOpenMPDeclareReductionInitializerStart(
         /*S=*/nullptr, NewDRD);
     SemaRef.CurrentInstantiationScope->InstantiatedLocal(
         cast<DeclRefExpr>(D->getInitOrig())->getDecl(),
         cast<DeclRefExpr>(NewDRD->getInitOrig())->getDecl());
     SemaRef.CurrentInstantiationScope->InstantiatedLocal(
         cast<DeclRefExpr>(D->getInitPriv())->getDecl(),
         cast<DeclRefExpr>(NewDRD->getInitPriv())->getDecl());
     if (D->getInitializerKind() == OMPDeclareReductionDecl::CallInit) {
-      SubstInitializer = SemaRef.SubstExpr(Init, TemplateArgs).get();
+      SubstInitializer =
+          SemaRef.SubstExpr(Init, TemplateArgs, EarlySubstitution).get();
     } else {
       auto *OldPrivParm =
           cast<VarDecl>(cast<DeclRefExpr>(D->getInitPriv())->getDecl());
       IsCorrect = IsCorrect && OldPrivParm->hasInit();
       if (IsCorrect)
         SemaRef.InstantiateVariableInitializer(OmpPrivParm, OldPrivParm,
-                                               TemplateArgs);
+                                               TemplateArgs, EarlySubstitution);
     }
     SemaRef.ActOnOpenMPDeclareReductionInitializerEnd(NewDRD, SubstInitializer,
                                                       OmpPrivParm);
   }
   IsCorrect = IsCorrect && SubstCombiner &&
               (!Init ||
                (D->getInitializerKind() == OMPDeclareReductionDecl::CallInit &&
                 SubstInitializer) ||
TemplateDeclInstantiator::VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) {
   const bool RequiresInstantiation =
       D->getType()->isDependentType() ||
       D->getType()->isInstantiationDependentType() ||
       D->getType()->containsUnexpandedParameterPack();
   QualType SubstMapperTy;
   DeclarationName VN = D->getVarName();
   if (RequiresInstantiation) {
     SubstMapperTy = SemaRef.ActOnOpenMPDeclareMapperType(
-        D->getLocation(),
-        ParsedType::make(SemaRef.SubstType(D->getType(), TemplateArgs,
-                                           D->getLocation(), VN)));
+        D->getLocation(), ParsedType::make(SemaRef.SubstType(
+                              D->getType(), TemplateArgs, EarlySubstitution,
   } else {
     SubstMapperTy = D->getType();
   }
   if (SubstMapperTy.isNull())
     return nullptr;
   // Create an instantiated copy of mapper.
   auto *PrevDeclInScope = D->getPrevDeclInScope();
   if (PrevDeclInScope && !PrevDeclInScope->isInvalidDecl()) {
TemplateDeclInstantiator::VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D) {
   auto *ThisContext = dyn_cast_or_null<CXXRecordDecl>(Owner);
   Sema::CXXThisScopeRAII ThisScope(SemaRef, ThisContext, Qualifiers(),
                                    ThisContext);
   // Instantiate map clauses.
   for (OMPClause *C : D->clauselists()) {
     auto *OldC = cast<OMPMapClause>(C);
     SmallVector<Expr *, 4> NewVars;
     for (Expr *OE : OldC->varlists()) {
-      Expr *NE = SemaRef.SubstExpr(OE, TemplateArgs).get();
+      Expr *NE = SemaRef.SubstExpr(OE, TemplateArgs, EarlySubstitution).get();
       if (!NE) {
         IsCorrect = false;
         break;
       }
       NewVars.push_back(NE);
     }
     if (!IsCorrect)
       break;
     NestedNameSpecifierLoc NewQualifierLoc =
         SemaRef.SubstNestedNameSpecifierLoc(OldC->getMapperQualifierLoc(),
-                                            TemplateArgs);
+                                            TemplateArgs, EarlySubstitution);
     CXXScopeSpec SS;
     SS.Adopt(NewQualifierLoc);
-    DeclarationNameInfo NewNameInfo =
-        SemaRef.SubstDeclarationNameInfo(OldC->getMapperIdInfo(), TemplateArgs);
+    DeclarationNameInfo NewNameInfo = SemaRef.SubstDeclarationNameInfo(
+        OldC->getMapperIdInfo(), TemplateArgs, EarlySubstitution);
     OMPVarListLocTy Locs(OldC->getBeginLoc(), OldC->getLParenLoc(),
                          OldC->getEndLoc());
     OMPClause *NewC = SemaRef.ActOnOpenMPMapClause(
         OldC->getMapTypeModifiers(), OldC->getMapTypeModifiersLoc(), SS,
         NewNameInfo, OldC->getMapType(), OldC->isImplicitMapType(),
         OldC->getMapLoc(), OldC->getColonLoc(), NewVars, Locs);
     Clauses.push_back(NewC);
   }
assert(ClassTemplate->getDeclContext()->isRecord() &&
          D->getTemplateSpecializationKind() == TSK_ExplicitSpecialization &&
          "can only instantiate an explicit specialization "
          "for a member class template");
 
   // Lookup the already-instantiated declaration in the instantiation
   // of the class template.
   ClassTemplateDecl *InstClassTemplate =
       cast_or_null<ClassTemplateDecl>(SemaRef.FindInstantiatedDecl(
-          D->getLocation(), ClassTemplate, TemplateArgs));
+          D->getLocation(), ClassTemplate, TemplateArgs, EarlySubstitution,
+          /*FindingInstantiatedContext=*/false));
   if (!InstClassTemplate)
     return nullptr;
 
   // Substitute into the template arguments of the class template explicit
   // specialization.
   TemplateSpecializationTypeLoc Loc = D->getTypeAsWritten()->getTypeLoc().
                                         castAs<TemplateSpecializationTypeLoc>();
   TemplateArgumentListInfo InstTemplateArgs(Loc.getLAngleLoc(),
                                             Loc.getRAngleLoc());
   SmallVector<TemplateArgumentLoc, 4> ArgLocs;
   for (unsigned I = 0; I != Loc.getNumArgs(); ++I)
     ArgLocs.push_back(Loc.getArgLoc(I));
-  if (SemaRef.SubstTemplateArguments(ArgLocs, TemplateArgs, InstTemplateArgs))
+  if (SemaRef.SubstTemplateArguments(ArgLocs, TemplateArgs, EarlySubstitution,
+                                     InstTemplateArgs))
     return nullptr;
 
   // Check that the template argument list is well-formed for this
   // class template.
   SmallVector<TemplateArgument, 4> Converted;
   if (SemaRef.CheckTemplateArgumentList(InstClassTemplate,
                                         D->getLocation(),
                                         InstTemplateArgs,
TemplateDeclInstantiator::VisitClassTemplateSpecializationDecl(
   Owner->addDecl(InstD);
 
   // Instantiate the members of the class-scope explicit specialization eagerly.
   // We don't have support for lazy instantiation of an explicit specialization
   // yet, and MSVC eagerly instantiates in this case.
   // FIXME: This is wrong in standard C++.
   if (D->isThisDeclarationADefinition() &&
       SemaRef.InstantiateClass(D->getLocation(), InstD, D, TemplateArgs,
-                               TSK_ImplicitInstantiation,
+                               EarlySubstitution, TSK_ImplicitInstantiation,
                                /*Complain=*/true))
     return nullptr;
 
   return InstD;
 }
 
 Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
     VarTemplateSpecializationDecl *D) {
 
   TemplateArgumentListInfo VarTemplateArgsInfo;
   VarTemplateDecl *VarTemplate = D->getSpecializedTemplate();
   assert(VarTemplate &&
          "A template specialization without specialized template?");
 
   VarTemplateDecl *InstVarTemplate =
       cast_or_null<VarTemplateDecl>(SemaRef.FindInstantiatedDecl(
-          D->getLocation(), VarTemplate, TemplateArgs));
+          D->getLocation(), VarTemplate, TemplateArgs, EarlySubstitution,
+          /*FindingInstantiatedContext=*/false));
   if (!InstVarTemplate)
     return nullptr;
 
   // Substitute the current template arguments.
   if (const ASTTemplateArgumentListInfo *TemplateArgsInfo =
           D->getTemplateArgsInfo()) {
     VarTemplateArgsInfo.setLAngleLoc(TemplateArgsInfo->getLAngleLoc());
     VarTemplateArgsInfo.setRAngleLoc(TemplateArgsInfo->getRAngleLoc());
 
     if (SemaRef.SubstTemplateArguments(TemplateArgsInfo->arguments(),
-                                       TemplateArgs, VarTemplateArgsInfo))
+                                       TemplateArgs, EarlySubstitution,
+                                       VarTemplateArgsInfo))
       return nullptr;
   }
 
   // Check that the template argument list is well-formed for this template.
   SmallVector<TemplateArgument, 4> Converted;
   if (SemaRef.CheckTemplateArgumentList(InstVarTemplate, D->getLocation(),
                                         VarTemplateArgsInfo, false, Converted,
                                         /*UpdateArgsWithConversions=*/true))

 Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
     VarTemplateDecl *VarTemplate, VarDecl *D,
     const TemplateArgumentListInfo &TemplateArgsInfo,
     ArrayRef<TemplateArgument> Converted,
     VarTemplateSpecializationDecl *PrevDecl) {
 
   // Do substitution on the type of the declaration
   TypeSourceInfo *DI =
-      SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs,
-                        D->getTypeSpecStartLoc(), D->getDeclName());
+      SemaRef.SubstType(D->getTypeSourceInfo(), TemplateArgs, EarlySubstitution,
+                        D->getTypeSpecStartLoc(), D->getDeclName(),
+                        /*AllowDeducedTST=*/false);
   if (!DI)
     return nullptr;
 
   if (DI->getType()->isFunctionType()) {
     SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function)
         << D->isStaticDataMember() << DI->getType();
     return nullptr;
   }
Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
 
   if (SemaRef.getLangOpts().OpenCL)
     SemaRef.deduceOpenCLAddressSpace(Var);
 
   // Substitute the nested name specifier, if any.
   if (SubstQualifier(D, Var))
     return nullptr;
 
-  SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, LateAttrs, Owner,
-                                     StartingScope, false, PrevDecl);
+  SemaRef.BuildVariableInstantiation(Var, D, TemplateArgs, EarlySubstitution,
+                                     LateAttrs, Owner, StartingScope, false,
+                                     PrevDecl);
 
   return Var;
 }
 
 Decl *TemplateDeclInstantiator::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D) {
   llvm_unreachable("@defs is not supported in Objective-C++");
 }
 
return RequiresExprBodyDecl::Create(SemaRef.Context, D->getDeclContext(),
                                       D->getBeginLoc());
 }
 
 Decl *TemplateDeclInstantiator::VisitDecl(Decl *D) {
   llvm_unreachable("Unexpected decl");
 }
 
 Decl *Sema::SubstDecl(Decl *D, DeclContext *Owner,
-                      const MultiLevelTemplateArgumentList &TemplateArgs) {
-  TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs);
+                      const MultiLevelTemplateArgumentList &TemplateArgs,
+                      bool EarlySubstitution) {
+  TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs,
+                                        EarlySubstitution);
   if (D->isInvalidDecl())
     return nullptr;
 
   Decl *SubstD;
-  runWithSufficientStackSpace(D->getLocation(), [&] {
-    SubstD = Instantiator.Visit(D);
-  });
+  runWithSufficientStackSpace(D->getLocation(),
+                              [&] { SubstD = Instantiator.Visit(D); });
   return SubstD;
 }
 
 void TemplateDeclInstantiator::adjustForRewrite(RewriteKind RK,
                                                 FunctionDecl *Orig, QualType &T,
                                                 TypeSourceInfo *&TInfo,
                                                 DeclarationNameInfo &NameInfo) {
   assert(RK == RewriteKind::RewriteSpaceshipAsEqualEqual);
FunctionDecl *Sema::SubstSpaceshipAsEqualEqual(CXXRecordDecl *RD,
 
   // C++2a [class.compare.default]p3:
   //   an == operator function is declared implicitly [...] with the same
   //   access and function-definition and in the same class scope as the
   //   three-way comparison operator function
   MultiLevelTemplateArgumentList NoTemplateArgs;
   NoTemplateArgs.setKind(TemplateSubstitutionKind::Rewrite);
   NoTemplateArgs.addOuterRetainedLevels(RD->getTemplateDepth());
-  TemplateDeclInstantiator Instantiator(*this, RD, NoTemplateArgs);
+  TemplateDeclInstantiator Instantiator(*this, RD, NoTemplateArgs,
+                                        /*EarlySubstitution=*/false);
   Decl *R;
   if (auto *MD = dyn_cast<CXXMethodDecl>(Spaceship)) {
     R = Instantiator.VisitCXXMethodDecl(
         MD, nullptr, None,
         TemplateDeclInstantiator::RewriteKind::RewriteSpaceshipAsEqualEqual);
   } else {
     assert(Spaceship->getFriendObjectKind() &&
            "defaulted spaceship is neither a member nor a friend");
if (Invalid)
     return nullptr;
 
   // FIXME: Concepts: Substitution into requires clause should only happen when
   // checking satisfaction.
   Expr *InstRequiresClause = nullptr;
   if (Expr *E = L->getRequiresClause()) {
     EnterExpressionEvaluationContext ConstantEvaluated(
         SemaRef, Sema::ExpressionEvaluationContext::Unevaluated);
-    ExprResult Res = SemaRef.SubstExpr(E, TemplateArgs);
+    ExprResult Res =
+        SemaRef.SubstExpr(E, TemplateArgs, /*EarlySubstitution=*/false);
     if (Res.isInvalid() || !Res.isUsable()) {
       return nullptr;
     }
     InstRequiresClause = Res.get();
   }
 
   TemplateParameterList *InstL
     = TemplateParameterList::Create(SemaRef.Context, L->getTemplateLoc(),
                                     L->getLAngleLoc(), Params,
                                     L->getRAngleLoc(), InstRequiresClause);
   return InstL;
 }
 
 TemplateParameterList *
 Sema::SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner,
-                          const MultiLevelTemplateArgumentList &TemplateArgs) {
-  TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs);
+                          const MultiLevelTemplateArgumentList &TemplateArgs,
+                          bool EarlySubstitution) {
+  TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs,
+                                        EarlySubstitution);
   return Instantiator.SubstTemplateParams(Params);
 }
 
 /// Instantiate the declaration of a class template partial
 /// specialization.
 ///
 /// \param ClassTemplate the (instantiated) class template that is partially
 // specialized by the instantiation of \p PartialSpec.
TemplateDeclInstantiator::InstantiateClassTemplatePartialSpecialization(
 
   // Substitute into the template arguments of the class template partial
   // specialization.
   const ASTTemplateArgumentListInfo *TemplArgInfo
     = PartialSpec->getTemplateArgsAsWritten();
   TemplateArgumentListInfo InstTemplateArgs(TemplArgInfo->LAngleLoc,
                                             TemplArgInfo->RAngleLoc);
   if (SemaRef.SubstTemplateArguments(TemplArgInfo->arguments(), TemplateArgs,
-                                     InstTemplateArgs))
+                                     EarlySubstitution, InstTemplateArgs))
     return nullptr;
 
   // Check that the template argument list is well-formed for this
   // class template.
   SmallVector<TemplateArgument, 4> Converted;
   if (SemaRef.CheckTemplateArgumentList(ClassTemplate,
                                         PartialSpec->getLocation(),
                                         InstTemplateArgs,
TemplateDeclInstantiator::InstantiateVarTemplatePartialSpecialization(
 
   // Substitute into the template arguments of the variable template partial
   // specialization.
   const ASTTemplateArgumentListInfo *TemplArgInfo
     = PartialSpec->getTemplateArgsAsWritten();
   TemplateArgumentListInfo InstTemplateArgs(TemplArgInfo->LAngleLoc,
                                             TemplArgInfo->RAngleLoc);
   if (SemaRef.SubstTemplateArguments(TemplArgInfo->arguments(), TemplateArgs,
-                                     InstTemplateArgs))
+                                     EarlySubstitution, InstTemplateArgs))
     return nullptr;
 
   // Check that the template argument list is well-formed for this
   // class template.
   SmallVector<TemplateArgument, 4> Converted;
   if (SemaRef.CheckTemplateArgumentList(VarTemplate, PartialSpec->getLocation(),
                                         InstTemplateArgs, false, Converted))
     return nullptr;
SemaRef.Diag(PartialSpec->getLocation(),
         << WrittenTy->getType();
     SemaRef.Diag(PrevDecl->getLocation(),
                  diag::note_var_prev_partial_spec_here);
     return nullptr;
   }
 
   // Do substitution on the type of the declaration
   TypeSourceInfo *DI = SemaRef.SubstType(
-      PartialSpec->getTypeSourceInfo(), TemplateArgs,
-      PartialSpec->getTypeSpecStartLoc(), PartialSpec->getDeclName());
+      PartialSpec->getTypeSourceInfo(), TemplateArgs, EarlySubstitution,
+      PartialSpec->getTypeSpecStartLoc(), PartialSpec->getDeclName(),
+      /*AllowDeducedTST=*/false);
   if (!DI)
     return nullptr;
 
   if (DI->getType()->isFunctionType()) {
     SemaRef.Diag(PartialSpec->getLocation(),
                  diag::err_variable_instantiates_to_function)
         << PartialSpec->isStaticDataMember() << DI->getType();
     return nullptr;
TemplateDeclInstantiator::InstantiateVarTemplatePartialSpecialization(
 
   // Check the completed partial specialization.
   SemaRef.CheckTemplatePartialSpecialization(InstPartialSpec);
 
   // Add this partial specialization to the set of variable template partial
   // specializations. The instantiation of the initializer is not necessary.
   VarTemplate->AddPartialSpecialization(InstPartialSpec, /*InsertPos=*/nullptr);
 
-  SemaRef.BuildVariableInstantiation(InstPartialSpec, PartialSpec, TemplateArgs,
-                                     LateAttrs, Owner, StartingScope);
+  SemaRef.BuildVariableInstantiation(
+      InstPartialSpec, PartialSpec, TemplateArgs, EarlySubstitution, LateAttrs,
+      Owner, StartingScope, /*InstantiatingVarTemplate=*/false,
+      /*PrevVTSD=*/nullptr);
 
   return InstPartialSpec;
 }
 
 TypeSourceInfo*
 TemplateDeclInstantiator::SubstFunctionType(FunctionDecl *D,
                               SmallVectorImpl<ParmVarDecl *> &Params) {
   TypeSourceInfo *OldTInfo = D->getTypeSourceInfo();
   assert(OldTInfo && "substituting function without type source info");
   assert(Params.empty() && "parameter vector is non-empty at start");
 
   CXXRecordDecl *ThisContext = nullptr;
   Qualifiers ThisTypeQuals;
   if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
     ThisContext = cast<CXXRecordDecl>(Owner);
     ThisTypeQuals = Method->getMethodQualifiers();
   }
 
-  TypeSourceInfo *NewTInfo
-    = SemaRef.SubstFunctionDeclType(OldTInfo, TemplateArgs,
-                                    D->getTypeSpecStartLoc(),
-                                    D->getDeclName(),
-                                    ThisContext, ThisTypeQuals);
+  TypeSourceInfo *NewTInfo = SemaRef.SubstFunctionDeclType(
+      OldTInfo, TemplateArgs, EarlySubstitution, D->getTypeSpecStartLoc(),
+      D->getDeclName(), ThisContext, ThisTypeQuals);
   if (!NewTInfo)
     return nullptr;
 
   TypeLoc OldTL = OldTInfo->getTypeLoc().IgnoreParens();
   if (FunctionProtoTypeLoc OldProtoLoc = OldTL.getAs<FunctionProtoTypeLoc>()) {
     if (NewTInfo != OldTInfo) {
       // Get parameters from the new type info.
       TypeLoc NewTL = NewTInfo->getTypeLoc().IgnoreParens();
if (FunctionProtoTypeLoc OldProtoLoc = OldTL.getAs<FunctionProtoTypeLoc>()) {
     //   functype func;
     //   int __cdecl meth(int, int);
     //
     // In this case, we'll just go instantiate the ParmVarDecls that we
     // synthesized in the method declaration.
     SmallVector<QualType, 4> ParamTypes;
     Sema::ExtParameterInfoBuilder ExtParamInfos;
     if (SemaRef.SubstParmTypes(D->getLocation(), D->parameters(), nullptr,
-                               TemplateArgs, ParamTypes, &Params,
-                               ExtParamInfos))
+                               TemplateArgs, EarlySubstitution, ParamTypes,
+                               &Params, ExtParamInfos))
       return nullptr;
   }
 
   return NewTInfo;
 }
 
 /// Introduce the instantiated function parameters into the local
 /// instantiation scope, and set the parameter names to those used
 /// in the template.
 bool Sema::addInstantiatedParametersToScope(
     FunctionDecl *Function, const FunctionDecl *PatternDecl,
     LocalInstantiationScope &Scope,
-    const MultiLevelTemplateArgumentList &TemplateArgs) {
+    const MultiLevelTemplateArgumentList &TemplateArgs,
+    bool EarlySubstitution) {
   unsigned FParamIdx = 0;
   for (unsigned I = 0, N = PatternDecl->getNumParams(); I != N; ++I) {
     const ParmVarDecl *PatternParam = PatternDecl->getParamDecl(I);
     if (!PatternParam->isParameterPack()) {
       // Simple case: not a parameter pack.
       assert(FParamIdx < Function->getNumParams());
       ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
       FunctionParam->setDeclName(PatternParam->getDeclName());
       // If the parameter's type is not dependent, update it to match the type
       // in the pattern. They can differ in top-level cv-qualifiers, and we want
       // the pattern's type here. If the type is dependent, they can't differ,
       // per core issue 1668. Substitute into the type from the pattern, in case
       // it's instantiation-dependent.
       // FIXME: Updating the type to work around this is at best fragile.
       if (!PatternDecl->getType()->isDependentType()) {
         QualType T = SubstType(PatternParam->getType(), TemplateArgs,
-                               FunctionParam->getLocation(),
+                               EarlySubstitution, FunctionParam->getLocation(),
                                FunctionParam->getDeclName());
         if (T.isNull())
           return true;
         FunctionParam->setType(T);
       }
 
       Scope.InstantiatedLocal(PatternParam, FunctionParam);
       ++FParamIdx;
       continue;
     }
 
     // Expand the parameter pack.
     Scope.MakeInstantiatedLocalArgPack(PatternParam);
     Optional<unsigned> NumArgumentsInExpansion =
         getNumArgumentsInExpansion(PatternParam->getType(), TemplateArgs);
     if (NumArgumentsInExpansion) {
       QualType PatternType =
           PatternParam->getType()->castAs<PackExpansionType>()->getPattern();
       for (unsigned Arg = 0; Arg < *NumArgumentsInExpansion; ++Arg) {
         ParmVarDecl *FunctionParam = Function->getParamDecl(FParamIdx);
         FunctionParam->setDeclName(PatternParam->getDeclName());
         if (!PatternDecl->getType()->isDependentType()) {
           Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, Arg);
-          QualType T =
-              SubstType(PatternType, TemplateArgs, FunctionParam->getLocation(),
+          QualType T = SubstType(PatternType, TemplateArgs, EarlySubstitution,
+                                 FunctionParam->getLocation(),
                                  FunctionParam->getDeclName());
           if (T.isNull())
             return true;
           FunctionParam->setType(T);
         }
 
         Scope.InstantiatedLocalPackArg(PatternParam, FunctionParam);
         ++FParamIdx;
       }
ExprResult Result;
     //   The names in the [default argument] expression are bound, and
     //   the semantic constraints are checked, at the point where the
     //   default argument expression appears.
     ContextRAII SavedContext(*this, FD);
     LocalInstantiationScope Local(*this);
 
     FunctionDecl *Pattern = FD->getTemplateInstantiationPattern(
         /*ForDefinition*/ false);
-    if (addInstantiatedParametersToScope(FD, Pattern, Local, TemplateArgs))
+    if (addInstantiatedParametersToScope(FD, Pattern, Local, TemplateArgs,
+                                         /*EarlySubstitution=*/false))
       return true;
 
     runWithSufficientStackSpace(CallLoc, [&] {
       Result = SubstInitializer(UninstExpr, TemplateArgs,
-                                /*DirectInit*/false);
+                                /*EarlySubstitution=*/false,
+                                /*DirectInit*/ false);
     });
   }
   if (Result.isInvalid())
     return true;
 
   // Check the expression as an initializer for the parameter.
   InitializedEntity Entity
     = InitializedEntity::InitializeParameter(Context, Param);
void Sema::InstantiateExceptionSpec(SourceLocation PointOfInstantiation,
   MultiLevelTemplateArgumentList TemplateArgs =
     getTemplateInstantiationArgs(Decl, nullptr, /*RelativeToPrimary*/true);
 
   // FIXME: We can't use getTemplateInstantiationPattern(false) in general
   // here, because for a non-defining friend declaration in a class template,
   // we don't store enough information to map back to the friend declaration in
   // the template.
   FunctionDecl *Template = Proto->getExceptionSpecTemplate();
-  if (addInstantiatedParametersToScope(Decl, Template, Scope, TemplateArgs)) {
+  if (addInstantiatedParametersToScope(Decl, Template, Scope, TemplateArgs,
+                                       /*EarlySubstitution=*/false)) {
     UpdateExceptionSpec(Decl, EST_None);
     return;
   }
 
   SubstExceptionSpec(Decl, Template->getType()->castAs<FunctionProtoType>(),
-                     TemplateArgs);
+                     TemplateArgs, /*EarlySubstitution=*/false);
 }
 
 /// Initializes the common fields of an instantiation function
 /// declaration (New) from the corresponding fields of its template (Tmpl).
 ///
 /// \returns true if there was an error
 bool
 TemplateDeclInstantiator::InitFunctionInstantiation(FunctionDecl *New,
if (SemaRef.getLangOpts().CPlusPlus11 &&
       EPI = NewProto->getExtProtoInfo();
       EPI.ExceptionSpec.Type = NewEST;
       EPI.ExceptionSpec.SourceDecl = New;
       EPI.ExceptionSpec.SourceTemplate = ExceptionSpecTemplate;
       New->setType(SemaRef.Context.getFunctionType(
           NewProto->getReturnType(), NewProto->getParamTypes(), EPI));
     } else {
       Sema::ContextRAII SwitchContext(SemaRef, New);
-      SemaRef.SubstExceptionSpec(New, Proto, TemplateArgs);
+      SemaRef.SubstExceptionSpec(New, Proto, TemplateArgs, EarlySubstitution);
     }
   }
 
   // Get the definition. Leaves the variable unchanged if undefined.
   const FunctionDecl *Definition = Tmpl;
   Tmpl->isDefined(Definition);
 
-  SemaRef.InstantiateAttrs(TemplateArgs, Definition, New,
-                           LateAttrs, StartingScope);
+  SemaRef.InstantiateAttrs(TemplateArgs, /*EarlySubstitution=*/false,
+                           Definition, New, LateAttrs, StartingScope);
 
   return false;
 }
 
 /// Initializes common fields of an instantiated method
 /// declaration (New) from the corresponding fields of its template
 /// (Tmpl).
 ///

 bool TemplateDeclInstantiator::SubstDefaultedFunction(FunctionDecl *New,
                                                       FunctionDecl *Tmpl) {
   // Transfer across any unqualified lookups.
   if (auto *DFI = Tmpl->getDefaultedFunctionInfo()) {
     SmallVector<DeclAccessPair, 32> Lookups;
     Lookups.reserve(DFI->getUnqualifiedLookups().size());
     bool AnyChanged = false;
     for (DeclAccessPair DA : DFI->getUnqualifiedLookups()) {
-      NamedDecl *D = SemaRef.FindInstantiatedDecl(New->getLocation(),
-                                                  DA.getDecl(), TemplateArgs);
+      NamedDecl *D = SemaRef.FindInstantiatedDecl(
+          New->getLocation(), DA.getDecl(), TemplateArgs, EarlySubstitution,
+          /*FindingInstantiatedContext=*/false);
       if (!D)
         return true;
       AnyChanged |= (D != DA.getDecl());
       Lookups.push_back(DeclAccessPair::make(D, DA.getAccess()));
     }
 
     // It's unlikely that substitution will change any declarations. Don't
     // store an unnecessary copy in that case.
     New->setDefaultedFunctionInfo(
         AnyChanged ? FunctionDecl::DefaultedFunctionInfo::Create(
                          SemaRef.Context, Lookups)
                    : DFI);
   }
 
   SemaRef.SetDeclDefaulted(New, Tmpl->getLocation());
   return false;
 }
 
 /// Instantiate (or find existing instantiation of) a function template with a
 /// given set of template arguments.
 ///
 /// Usually this should not be used, and template argument deduction should be
 /// used in its place.
-FunctionDecl *
-Sema::InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD,
-                                     const TemplateArgumentList *Args,
-                                     SourceLocation Loc) {
+FunctionDecl *Sema::InstantiateFunctionDeclaration(
+    FunctionTemplateDecl *FTD, const TemplateArgumentList *Args,
+    bool EarlySubstitution, SourceLocation Loc) {
   FunctionDecl *FD = FTD->getTemplatedDecl();
 
   sema::TemplateDeductionInfo Info(Loc);
   InstantiatingTemplate Inst(
       *this, Loc, FTD, Args->asArray(),
       CodeSynthesisContext::ExplicitTemplateArgumentSubstitution, Info);
   if (Inst.isInvalid())
     return nullptr;
 
   ContextRAII SavedContext(*this, FD);
   MultiLevelTemplateArgumentList MArgs(*Args);
 
-  return cast_or_null<FunctionDecl>(SubstDecl(FD, FD->getParent(), MArgs));
+  return cast_or_null<FunctionDecl>(
+      SubstDecl(FD, FD->getParent(), MArgs, EarlySubstitution));
 }
 
 /// 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.
void Sema::InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
   } else {
     MultiLevelTemplateArgumentList TemplateArgs =
       getTemplateInstantiationArgs(Function, nullptr, false, PatternDecl);
 
     // Substitute into the qualifier; we can get a substitution failure here
     // through evil use of alias templates.
     // FIXME: Is CurContext correct for this? Should we go to the (instantiation
     // of the) lexical context of the pattern?
-    SubstQualifier(*this, PatternDecl, Function, TemplateArgs);
+    SubstQualifier(*this, PatternDecl, Function, TemplateArgs,
+                   /*EarlySubstitution=*/false);
 
     ActOnStartOfFunctionDef(nullptr, Function);
 
     // Enter the scope of this instantiation. We don't use
     // PushDeclContext because we don't have a scope.
     Sema::ContextRAII savedContext(*this, Function);
 
     if (addInstantiatedParametersToScope(Function, PatternDecl, Scope,
-                                         TemplateArgs))
+                                         TemplateArgs,
+                                         /*EarlySubstitution=*/false))
       return;
 
     StmtResult Body;
     if (PatternDecl->hasSkippedBody()) {
       ActOnSkippedFunctionBody(Function);
       Body = nullptr;
     } else {
       if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Function)) {
         // If this is a constructor, instantiate the member initializers.
         InstantiateMemInitializers(Ctor, cast<CXXConstructorDecl>(PatternDecl),
-                                   TemplateArgs);
+                                   TemplateArgs, /*EarlySubstitution=*/false);
 
         // If this is an MS ABI dllexport default constructor, instantiate any
         // default arguments.
         if (Context.getTargetInfo().getCXXABI().isMicrosoft() &&
             Ctor->isDefaultConstructor()) {
           InstantiateDefaultCtorDefaultArgs(Ctor);
         }
       }
 
       // Instantiate the function body.
-      Body = SubstStmt(Pattern, TemplateArgs);
+      Body = SubstStmt(Pattern, TemplateArgs, /*EarlySubstitution=*/false);
 
       if (Body.isInvalid())
         Function->setInvalidDecl();
     }
     // FIXME: finishing the function body while in an expression evaluation
     // context seems wrong. Investigate more.
     ActOnFinishFunctionBody(Function, Body.get(), /*IsInstantiation=*/true);
 
-    PerformDependentDiagnostics(PatternDecl, TemplateArgs);
+    PerformDependentDiagnostics(PatternDecl, TemplateArgs,
+                                /*EarlySubstitution=*/false);
 
     if (auto *Listener = getASTMutationListener())
       Listener->FunctionDefinitionInstantiated(Function);
 
     savedContext.pop();
   }
 
   DeclGroupRef DG(Function);
if (VarTemplatePartialSpecializationDecl *PartialSpec =
     IsMemberSpec = PartialSpec->isMemberSpecialization();
   else if (VarTemplateDecl *FromTemplate = FromVar->getDescribedVarTemplate())
     IsMemberSpec = FromTemplate->isMemberSpecialization();
   if (!IsMemberSpec)
     FromVar = FromVar->getFirstDecl();
 
   MultiLevelTemplateArgumentList MultiLevelList(TemplateArgList);
   TemplateDeclInstantiator Instantiator(*this, FromVar->getDeclContext(),
-                                        MultiLevelList);
+                                        MultiLevelList,
+                                        /*EarlySubstitution=*/false);
 
   // TODO: Set LateAttrs and StartingScope ...
 
   return cast_or_null<VarTemplateSpecializationDecl>(
       Instantiator.VisitVarTemplateSpecializationDecl(
           VarTemplate, FromVar, TemplateArgsInfo, Converted));
 }
 
 /// Instantiates a variable template specialization by completing it
 /// with appropriate type information and initializer.
 VarTemplateSpecializationDecl *Sema::CompleteVarTemplateSpecializationDecl(
     VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl,
-    const MultiLevelTemplateArgumentList &TemplateArgs) {
+    const MultiLevelTemplateArgumentList &TemplateArgs,
+    bool EarlySubstitution) {
   assert(PatternDecl->isThisDeclarationADefinition() &&
          "don't have a definition to instantiate from");
 
   // Do substitution on the type of the declaration
-  TypeSourceInfo *DI =
-      SubstType(PatternDecl->getTypeSourceInfo(), TemplateArgs,
-                PatternDecl->getTypeSpecStartLoc(), PatternDecl->getDeclName());
+  TypeSourceInfo *DI = SubstType(
+      PatternDecl->getTypeSourceInfo(), TemplateArgs, EarlySubstitution,
+      PatternDecl->getTypeSpecStartLoc(), PatternDecl->getDeclName(),
+      /*AllowDeducedTST=*/false);
   if (!DI)
     return nullptr;
 
   // Update the type of this variable template specialization.
   VarSpec->setType(DI->getType());
 
   // Convert the declaration into a definition now.
   VarSpec->setCompleteDefinition();
 
   // Instantiate the initializer.
-  InstantiateVariableInitializer(VarSpec, PatternDecl, TemplateArgs);
+  InstantiateVariableInitializer(VarSpec, PatternDecl, TemplateArgs,
+                                 EarlySubstitution);
 
   if (getLangOpts().OpenCL)
     deduceOpenCLAddressSpace(VarSpec);
 
   return VarSpec;
 }
 
 /// BuildVariableInstantiation - Used after a new variable has been created.
 /// Sets basic variable data and decides whether to postpone the
 /// variable instantiation.
 void Sema::BuildVariableInstantiation(
     VarDecl *NewVar, VarDecl *OldVar,
-    const MultiLevelTemplateArgumentList &TemplateArgs,
+    const MultiLevelTemplateArgumentList &TemplateArgs, bool EarlySubstitution,
     LateInstantiatedAttrVec *LateAttrs, DeclContext *Owner,
-    LocalInstantiationScope *StartingScope,
-    bool InstantiatingVarTemplate,
+    LocalInstantiationScope *StartingScope, bool InstantiatingVarTemplate,
     VarTemplateSpecializationDecl *PrevDeclForVarTemplateSpecialization) {
   // Instantiating a partial specialization to produce a partial
   // specialization.
   bool InstantiatingVarTemplatePartialSpec =
       isa<VarTemplatePartialSpecializationDecl>(OldVar) &&
       isa<VarTemplatePartialSpecializationDecl>(NewVar);
   // Instantiating from a variable template (or partial specialization) to
   // produce a variable template specialization.
void Sema::BuildVariableInstantiation(
   NewVar->setAccess(OldVar->getAccess());
 
   if (!OldVar->isStaticDataMember()) {
     if (OldVar->isUsed(false))
       NewVar->setIsUsed();
     NewVar->setReferenced(OldVar->isReferenced());
   }
 
-  InstantiateAttrs(TemplateArgs, OldVar, NewVar, LateAttrs, StartingScope);
+  InstantiateAttrs(TemplateArgs, EarlySubstitution, OldVar, NewVar, LateAttrs,
+                   StartingScope);
 
   LookupResult Previous(
       *this, NewVar->getDeclName(), NewVar->getLocation(),
       NewVar->isLocalExternDecl() ? Sema::LookupRedeclarationWithLinkage
                                   : Sema::LookupOrdinaryName,
       NewVar->isLocalExternDecl() ? Sema::ForExternalRedeclaration
                                   : forRedeclarationInCurContext());
 
   if (NewVar->isLocalExternDecl() && OldVar->getPreviousDecl() &&
       (!OldVar->getPreviousDecl()->getDeclContext()->isDependentContext() ||
        OldVar->getPreviousDecl()->getDeclContext()==OldVar->getDeclContext())) {
     // We have a previous declaration. Use that one, so we merge with the
     // right type.
     if (NamedDecl *NewPrev = FindInstantiatedDecl(
-            NewVar->getLocation(), OldVar->getPreviousDecl(), TemplateArgs))
+            NewVar->getLocation(), OldVar->getPreviousDecl(), TemplateArgs,
+            EarlySubstitution,
+            /*FindingInstantiatedContext=*/false))
       Previous.addDecl(NewPrev);
   } else if (!isa<VarTemplateSpecializationDecl>(NewVar) &&
              OldVar->hasLinkage()) {
     LookupQualifiedName(Previous, NewVar->getDeclContext(), false);
   } else if (PrevDeclForVarTemplateSpecialization) {
     Previous.addDecl(PrevDeclForVarTemplateSpecialization);
   }
   CheckVariableDeclaration(NewVar, Previous);
void Sema::BuildVariableInstantiation(
   Context.setManglingNumber(NewVar, Context.getManglingNumber(OldVar));
   Context.setStaticLocalNumber(NewVar, Context.getStaticLocalNumber(OldVar));
 
   // Figure out whether to eagerly instantiate the initializer.
   if (InstantiatingVarTemplate || InstantiatingVarTemplatePartialSpec) {
     // We're producing a template. Don't instantiate the initializer yet.
   } else if (NewVar->getType()->isUndeducedType()) {
     // We need the type to complete the declaration of the variable.
-    InstantiateVariableInitializer(NewVar, OldVar, TemplateArgs);
+    InstantiateVariableInitializer(NewVar, OldVar, TemplateArgs,
+                                   EarlySubstitution);
   } else if (InstantiatingSpecFromTemplate ||
              (OldVar->isInline() && OldVar->isThisDeclarationADefinition() &&
               !NewVar->isThisDeclarationADefinition())) {
     // Delay instantiation of the initializer for variable template
     // specializations or inline static data members until a definition of the
     // variable is needed.
   } else {
-    InstantiateVariableInitializer(NewVar, OldVar, TemplateArgs);
+    InstantiateVariableInitializer(NewVar, OldVar, TemplateArgs,
+                                   EarlySubstitution);
   }
 
   // Diagnose unused local variables with dependent types, where the diagnostic
   // will have been deferred.
   if (!NewVar->isInvalidDecl() &&
       NewVar->getDeclContext()->isFunctionOrMethod() &&
       OldVar->getType()->isDependentType())
     DiagnoseUnusedDecl(NewVar);
 }
 
 /// Instantiate the initializer of a variable.
 void Sema::InstantiateVariableInitializer(
     VarDecl *Var, VarDecl *OldVar,
-    const MultiLevelTemplateArgumentList &TemplateArgs) {
+    const MultiLevelTemplateArgumentList &TemplateArgs,
+    bool EarlySubstitution) {
   if (ASTMutationListener *L = getASTContext().getASTMutationListener())
     L->VariableDefinitionInstantiated(Var);
 
   // We propagate the 'inline' flag with the initializer, because it
   // would otherwise imply that the variable is a definition for a
   // non-static data member.
   if (OldVar->isInlineSpecified())
     Var->setInlineSpecified();
   else if (OldVar->isInline())
     Var->setImplicitlyInline();
 
   if (OldVar->getInit()) {
     EnterExpressionEvaluationContext Evaluated(
         *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated, Var);
 
     // Instantiate the initializer.
     ExprResult Init;
 
     {
       ContextRAII SwitchContext(*this, Var->getDeclContext());
-      Init = SubstInitializer(OldVar->getInit(), TemplateArgs,
-                              OldVar->getInitStyle() == VarDecl::CallInit);
+      Init =
+          SubstInitializer(OldVar->getInit(), TemplateArgs, EarlySubstitution,
     }
 
     if (!Init.isInvalid()) {
       Expr *InitExpr = Init.get();
 
       if (Var->hasAttr<DLLImportAttr>() &&
           (!InitExpr ||
            !InitExpr->isConstantInitializer(getASTContext(), false))) {
if (PatternDecl->isStaticDataMember() &&
       GlobalEagerInstantiationScope GlobalInstantiations(*this,
                                                          /*Enabled=*/Recursive);
       LocalInstantiationScope Local(*this);
       LocalEagerInstantiationScope LocalInstantiations(*this);
 
       // Enter the scope of this instantiation. We don't use
       // PushDeclContext because we don't have a scope.
       ContextRAII PreviousContext(*this, Var->getDeclContext());
-      InstantiateVariableInitializer(Var, PatternDecl, TemplateArgs);
+      InstantiateVariableInitializer(Var, PatternDecl, TemplateArgs,
+                                     /*EarlySubstitution=*/false);
       PreviousContext.pop();
 
       // This variable may have local implicit instantiations that need to be
       // instantiated within this scope.
       LocalInstantiations.perform();
       Local.Exit();
       GlobalInstantiations.perform();
     }
void Sema::InstantiateVariableDefinition(SourceLocation PointOfInstantiation,
   LocalInstantiationScope Local(*this);
 
   LocalEagerInstantiationScope LocalInstantiations(*this);
 
   VarDecl *OldVar = Var;
   if (Def->isStaticDataMember() && !Def->isOutOfLine()) {
     // We're instantiating an inline static data member whose definition was
     // provided inside the class.
-    InstantiateVariableInitializer(Var, Def, TemplateArgs);
+    InstantiateVariableInitializer(Var, Def, TemplateArgs,
+                                   /*EarlySubstitution=*/false);
   } else if (!VarSpec) {
-    Var = cast_or_null<VarDecl>(SubstDecl(Def, Var->getDeclContext(),
-                                          TemplateArgs));
+    Var = cast_or_null<VarDecl>(SubstDecl(
+        Def, Var->getDeclContext(), TemplateArgs, /*EarlySubstitution=*/false));
   } else if (Var->isStaticDataMember() &&
              Var->getLexicalDeclContext()->isRecord()) {
     // We need to instantiate the definition of a static data member template,
     // and all we have is the in-class declaration of it. Instantiate a separate
     // declaration of the definition.
     TemplateDeclInstantiator Instantiator(*this, Var->getDeclContext(),
-                                          TemplateArgs);
+                                          TemplateArgs,
+                                          /*EarlySubstitution=*/false);
 
     TemplateArgumentListInfo TemplateArgInfo;
     if (const ASTTemplateArgumentListInfo *ArgInfo =
             VarSpec->getTemplateArgsInfo()) {
       TemplateArgInfo.setLAngleLoc(ArgInfo->getLAngleLoc());
       TemplateArgInfo.setRAngleLoc(ArgInfo->getRAngleLoc());
       for (const TemplateArgumentLoc &Arg : ArgInfo->arguments())
         TemplateArgInfo.addArgument(Arg);
     }
 
     Var = cast_or_null<VarDecl>(Instantiator.VisitVarTemplateSpecializationDecl(
         VarSpec->getSpecializedTemplate(), Def, TemplateArgInfo,
         VarSpec->getTemplateArgs().asArray(), VarSpec));
     if (Var) {
       llvm::PointerUnion<VarTemplateDecl *,
                          VarTemplatePartialSpecializationDecl *> PatternPtr =
           VarSpec->getSpecializedTemplateOrPartial();
       if (VarTemplatePartialSpecializationDecl *Partial =
           PatternPtr.dyn_cast<VarTemplatePartialSpecializationDecl *>())
         cast<VarTemplateSpecializationDecl>(Var)->setInstantiationOf(
             Partial, &VarSpec->getTemplateInstantiationArgs());
 
       // Attach the initializer.
-      InstantiateVariableInitializer(Var, Def, TemplateArgs);
+      InstantiateVariableInitializer(Var, Def, TemplateArgs,
+                                     /*EarlySubstitution=*/false);
     }
   } else
     // Complete the existing variable's definition with an appropriately
     // substituted type and initializer.
-    Var = CompleteVarTemplateSpecializationDecl(VarSpec, Def, TemplateArgs);
+    Var = CompleteVarTemplateSpecializationDecl(VarSpec, Def, TemplateArgs,
+                                                /*EarlySubstitution=*/false);
 
   PreviousContext.pop();
 
   if (Var) {
     PassToConsumerRAII.Var = Var;
     Var->setTemplateSpecializationKind(OldVar->getTemplateSpecializationKind(),
                                        OldVar->getPointOfInstantiation());
   }
 
   // This variable may have local implicit instantiations that need to be
   // instantiated within this scope.
   LocalInstantiations.perform();
   Local.Exit();
   GlobalInstantiations.perform();
 }
 
-void
-Sema::InstantiateMemInitializers(CXXConstructorDecl *New,
-                                 const CXXConstructorDecl *Tmpl,
-                           const MultiLevelTemplateArgumentList &TemplateArgs) {
+void Sema::InstantiateMemInitializers(
+    CXXConstructorDecl *New, const CXXConstructorDecl *Tmpl,
+    const MultiLevelTemplateArgumentList &TemplateArgs,
+    bool EarlySubstitution) {
 
   SmallVector<CXXCtorInitializer*, 4> NewInits;
   bool AnyErrors = Tmpl->isInvalidDecl();
 
   // Instantiate all the initializers.
   for (const auto *Init : Tmpl->inits()) {
     // Only instantiate written initializers, let Sema re-construct implicit
     // ones.
if (Init->isPackExpansion()) {
       }
       assert(ShouldExpand && "Partial instantiation of base initializer?");
 
       // Loop over all of the arguments in the argument pack(s),
       for (unsigned I = 0; I != *NumExpansions; ++I) {
         Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(*this, I);
 
         // Instantiate the initializer.
-        ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
-                                               /*CXXDirectInit=*/true);
+        ExprResult TempInit =
+            SubstInitializer(Init->getInit(), TemplateArgs, EarlySubstitution,
         if (TempInit.isInvalid()) {
           AnyErrors = true;
           break;
         }
 
         // Instantiate the base type.
-        TypeSourceInfo *BaseTInfo = SubstType(Init->getTypeSourceInfo(),
-                                              TemplateArgs,
-                                              Init->getSourceLocation(),
-                                              New->getDeclName());
+        TypeSourceInfo *BaseTInfo = SubstType(
+            Init->getTypeSourceInfo(), TemplateArgs, EarlySubstitution,
+            Init->getSourceLocation(), New->getDeclName(),
+            /*AllowDeducedTST=*/false);
         if (!BaseTInfo) {
           AnyErrors = true;
           break;
         }
 
         // Build the initializer.
         MemInitResult NewInit = BuildBaseInitializer(BaseTInfo->getType(),
                                                      BaseTInfo, TempInit.get(),
                                                      New->getParent(),
                                                      SourceLocation());
         if (NewInit.isInvalid()) {
           AnyErrors = true;
           break;
         }
 
         NewInits.push_back(NewInit.get());
       }
 
       continue;
     }
 
     // Instantiate the initializer.
-    ExprResult TempInit = SubstInitializer(Init->getInit(), TemplateArgs,
-                                           /*CXXDirectInit=*/true);
+    ExprResult TempInit =
+        SubstInitializer(Init->getInit(), TemplateArgs, EarlySubstitution,
     if (TempInit.isInvalid()) {
       AnyErrors = true;
       continue;
     }
 
     MemInitResult NewInit;
     if (Init->isDelegatingInitializer() || Init->isBaseInitializer()) {
-      TypeSourceInfo *TInfo = SubstType(Init->getTypeSourceInfo(),
-                                        TemplateArgs,
-                                        Init->getSourceLocation(),
-                                        New->getDeclName());
+      TypeSourceInfo *TInfo =
+          SubstType(Init->getTypeSourceInfo(), TemplateArgs, EarlySubstitution,
+                    Init->getSourceLocation(), New->getDeclName(),
+                    /*AllowDeducedTST=*/false);
       if (!TInfo) {
         AnyErrors = true;
         New->setInvalidDecl();
         continue;
       }
 
       if (Init->isBaseInitializer())
         NewInit = BuildBaseInitializer(TInfo->getType(), TInfo, TempInit.get(),
                                        New->getParent(), EllipsisLoc);
       else
         NewInit = BuildDelegatingInitializer(TInfo, TempInit.get(),
                                   cast<CXXRecordDecl>(CurContext->getParent()));
     } else if (Init->isMemberInitializer()) {
-      FieldDecl *Member = cast_or_null<FieldDecl>(FindInstantiatedDecl(
-                                                     Init->getMemberLocation(),
-                                                     Init->getMember(),
-                                                     TemplateArgs));
+      FieldDecl *Member = cast_or_null<FieldDecl>(
+          FindInstantiatedDecl(Init->getMemberLocation(), Init->getMember(),
+                               TemplateArgs, EarlySubstitution,
+                               /*FindingInstantiatedContext=*/false));
       if (!Member) {
         AnyErrors = true;
         New->setInvalidDecl();
         continue;
       }
 
       NewInit = BuildMemberInitializer(Member, TempInit.get(),
                                        Init->getSourceLocation());
     } else if (Init->isIndirectMemberInitializer()) {
       IndirectFieldDecl *IndirectMember =
           cast_or_null<IndirectFieldDecl>(FindInstantiatedDecl(
-                                 Init->getMemberLocation(),
-                                 Init->getIndirectMember(), TemplateArgs));
+              Init->getMemberLocation(), Init->getIndirectMember(),
+              TemplateArgs, EarlySubstitution,
+              /*FindingInstantiatedContext=*/false));
 
       if (!IndirectMember) {
         AnyErrors = true;
         New->setInvalidDecl();
         continue;
       }
 
       NewInit = BuildMemberInitializer(IndirectMember, TempInit.get(),
static NamedDecl *findInstantiationOf(ASTContext &Ctx,
 
   return nullptr;
 }
 
 /// Finds the instantiation of the given declaration context
 /// within the current instantiation.
 ///
 /// \returns NULL if there was an error
-DeclContext *Sema::FindInstantiatedContext(SourceLocation Loc, DeclContext* DC,
-                          const MultiLevelTemplateArgumentList &TemplateArgs) {
+DeclContext *Sema::FindInstantiatedContext(
+    SourceLocation Loc, DeclContext *DC,
+    const MultiLevelTemplateArgumentList &TemplateArgs,
+    bool EarlySubstitution) {
   if (NamedDecl *D = dyn_cast<NamedDecl>(DC)) {
-    Decl* ID = FindInstantiatedDecl(Loc, D, TemplateArgs, true);
+    Decl *ID = FindInstantiatedDecl(Loc, D, TemplateArgs, EarlySubstitution,
+                                    /*FindingInstantiatedContext=*/true);
     return cast_or_null<DeclContext>(ID);
   } else return DC;
 }
 
 /// Determine whether the given context is dependent on template parameters at
 /// level \p Level or below.
 ///
 /// Sometimes we only substitute an inner set of template arguments and leave

 /// template struct X<int>;
 /// \endcode
 ///
 /// In the instantiation of X<int>::getKind(), we need to map the \p
 /// EnumConstantDecl for \p KnownValue (which refers to
 /// X<T>::<Kind>::KnownValue) to its instantiation (X<int>::<Kind>::KnownValue).
 /// \p FindInstantiatedDecl performs this mapping from within the instantiation
 /// of X<int>.
-NamedDecl *Sema::FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D,
+NamedDecl *
+Sema::FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D,
                            const MultiLevelTemplateArgumentList &TemplateArgs,
+                           bool EarlySubstitution,
                            bool FindingInstantiatedContext) {
   DeclContext *ParentDC = D->getDeclContext();
   // Determine whether our parent context depends on any of the template
   // arguments we're currently substituting.
   bool ParentDependsOnArgs = isDependentContextAtLevel(
       ParentDC, TemplateArgs.getNumRetainedOuterLevels());
   // FIXME: Parameters of pointer to functions (y below) that are themselves
   // parameters (p below) can have their ParentDC set to the translation-unit
   // - thus we can not consistently check if the ParentDC of such a parameter
if (isa<ParmVarDecl>(D) || isa<NonTypeTemplateParmDecl>(D) ||
     if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D))
       NeedInstantiate = RD->isLocalClass();
     else if (isa<TypedefNameDecl>(D) &&
              isa<CXXDeductionGuideDecl>(D->getDeclContext()))
       NeedInstantiate = true;
     else
       NeedInstantiate = isa<EnumDecl>(D);
     if (NeedInstantiate) {
-      Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
+      Decl *Inst = SubstDecl(D, CurContext, TemplateArgs, EarlySubstitution);
       CurrentInstantiationScope->InstantiatedLocal(D, Inst);
       return cast<TypeDecl>(Inst);
     }
 
     // If we didn't find the decl, then we must have a label decl that hasn't
     // been found yet.  Lazily instantiate it and return it now.
     assert(isa<LabelDecl>(D));
 
-    Decl *Inst = SubstDecl(D, CurContext, TemplateArgs);
+    Decl *Inst = SubstDecl(D, CurContext, TemplateArgs, EarlySubstitution);
     assert(Inst && "Failed to instantiate label??");
 
     CurrentInstantiationScope->InstantiatedLocal(D, Inst);
     return cast<LabelDecl>(Inst);
   }
 
   if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
     if (!Record->isDependentContext())
if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
 
     // Fall through to deal with other dependent record types (e.g.,
     // anonymous unions in class templates).
   }
 
   if (!ParentDependsOnArgs)
     return D;
 
-  ParentDC = FindInstantiatedContext(Loc, ParentDC, TemplateArgs);
+  ParentDC =
+      FindInstantiatedContext(Loc, ParentDC, TemplateArgs, EarlySubstitution);
   if (!ParentDC)
     return nullptr;
 
   if (ParentDC != D->getDeclContext()) {
     // We performed some kind of instantiation in the parent context,
     // so now we need to look into the instantiated parent context to
     // find the instantiation of the declaration D.
 
if (ParentDC != D->getDeclContext()) {
     }
 
     NamedDecl *Result = nullptr;
     // FIXME: If the name is a dependent name, this lookup won't necessarily
     // find it. Does that ever matter?
     if (auto Name = D->getDeclName()) {
       DeclarationNameInfo NameInfo(Name, D->getLocation());
       DeclarationNameInfo NewNameInfo =
-          SubstDeclarationNameInfo(NameInfo, TemplateArgs);
+          SubstDeclarationNameInfo(NameInfo, TemplateArgs, EarlySubstitution);
       Name = NewNameInfo.getName();
       if (!Name)
         return nullptr;
       DeclContext::lookup_result Found = ParentDC->lookup(Name);
 
       Result = findInstantiationOf(Context, D, Found.begin(), Found.end());
     } else {
       // Since we don't have a name for the entity we're looking for,
if (!Result) {
           << D->getDeclName()
           << Context.getTypeDeclType(cast<CXXRecordDecl>(ParentDC));
         Diag(D->getLocation(), diag::note_non_instantiated_member_here);
       } else if (EnumConstantDecl *ED = dyn_cast<EnumConstantDecl>(D)) {
         // This enumeration constant was found when the template was defined,
         // but can't be found in the instantiation. This can happen if an
         // unscoped enumeration member is explicitly specialized.
         EnumDecl *Enum = cast<EnumDecl>(ED->getLexicalDeclContext());
-        EnumDecl *Spec = cast<EnumDecl>(FindInstantiatedDecl(Loc, Enum,
-                                                             TemplateArgs));
+        EnumDecl *Spec = cast<EnumDecl>(
+            FindInstantiatedDecl(Loc, Enum, TemplateArgs, EarlySubstitution,
+                                 /*FindingInstantiatedContext=*/false));
         assert(Spec->getTemplateSpecializationKind() ==
                  TSK_ExplicitSpecialization);
         Diag(Loc, diag::err_enumerator_does_not_exist)
           << D->getDeclName()
           << Context.getTypeDeclType(cast<TypeDecl>(Spec->getDeclContext()));
         Diag(Spec->getLocation(), diag::note_enum_specialized_here)
           << Context.getTypeDeclType(Spec);
       } else {
while (!PendingLocalImplicitInstantiations.empty() ||
     InstantiateVariableDefinition(/*FIXME:*/ Inst.second, Var, true,
                                   DefinitionRequired, true);
   }
 
   if (!LocalOnly && LangOpts.PCHInstantiateTemplates)
     PendingInstantiations.swap(delayedPCHInstantiations);
 }
 
-void Sema::PerformDependentDiagnostics(const DeclContext *Pattern,
-                       const MultiLevelTemplateArgumentList &TemplateArgs) {
+void Sema::PerformDependentDiagnostics(
+    const DeclContext *Pattern,
+    const MultiLevelTemplateArgumentList &TemplateArgs,
+    bool EarlySubstitution) {
   for (auto DD : Pattern->ddiags()) {
     switch (DD->getKind()) {
     case DependentDiagnostic::Access:
-      HandleDependentAccessCheck(*DD, TemplateArgs);
+      HandleDependentAccessCheck(*DD, TemplateArgs, EarlySubstitution);
       break;
     }
   }
 }

clang/lib/Sema/SemaType.cpp

if (RD->isDependentContext()) {
       CXXRecordDecl *Pattern = RD->getInstantiatedFromMemberClass();
       if (!RD->isBeingDefined() && Pattern) {
         MemberSpecializationInfo *MSI = RD->getMemberSpecializationInfo();
         assert(MSI && "Missing member specialization information?");
         // This record was instantiated from a class within a template.
         if (MSI->getTemplateSpecializationKind() !=
             TSK_ExplicitSpecialization) {
           runWithSufficientStackSpace(Loc, [&] {
-            Diagnosed = InstantiateClass(Loc, RD, Pattern,
-                                         getTemplateInstantiationArgs(RD),
-                                         TSK_ImplicitInstantiation,
-                                         /*Complain=*/Diagnoser);
+            Diagnosed = InstantiateClass(
+                Loc, RD, Pattern, getTemplateInstantiationArgs(RD),
+                /*EarlySubstitution=*/false, TSK_ImplicitInstantiation,
           });
           Instantiated = true;
         }
       }
     }
 
     if (Instantiated) {
       // Instantiate* might have already complained that the template is not

clang/test/AST/ast-dump-template-decls.cpp

 using type2 = typename C<int>::type1<void>;
 // CHECK:      TypeAliasDecl 0x{{[^ ]*}} <line:[[@LINE-1]]:1, col:42> col:7 type2 'typename C<int>::type1<void>':'void (int)'
 // CHECK-NEXT: ElaboratedType 0x{{[^ ]*}} 'typename C<int>::type1<void>' sugar
 // CHECK-NEXT: TemplateSpecializationType 0x{{[^ ]*}} 'type1<void>' sugar alias type1
 // CHECK-NEXT: TemplateArgument type 'void'
 // CHECK-NEXT: BuiltinType 0x{{[^ ]*}} 'void'
 // CHECK-NEXT: FunctionProtoType 0x{{[^ ]*}} 'void (int)' cdecl
 // CHECK-NEXT: SubstTemplateTypeParmType 0x{{[^ ]*}} 'void' sugar
-// CHECK-NEXT: TemplateTypeParmType 0x{{[^ ]*}} 'U' dependent depth 0 index 0
+// CHECK-NEXT: TemplateTypeParmType 0x{{[^ ]*}} 'U' dependent depth 1 index 0
 // CHECK-NEXT: TemplateTypeParm 0x{{[^ ]*}} 'U'
 // CHECK-NEXT: BuiltinType 0x{{[^ ]*}} 'void'
 // CHECK-NEXT: SubstTemplateTypeParmType 0x{{[^ ]*}} 'int' sugar
 // CHECK-NEXT: TemplateTypeParmType 0x{{[^ ]*}} 'T' dependent depth 0 index 0
 } // namespace PR55886

clang/utils/TableGen/ClangAttrEmitter.cpp

void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
       OS << "tempInst" << getUpperName();
     }
 
     void writeTemplateInstantiation(raw_ostream &OS) const override {
       OS << "      " << getType() << " tempInst" << getUpperName() << ";\n";
       OS << "      {\n";
       OS << "        EnterExpressionEvaluationContext "
          << "Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);\n";
-      OS << "        ExprResult " << "Result = S.SubstExpr("
-         << "A->get" << getUpperName() << "(), TemplateArgs);\n";
+      OS << "        ExprResult "
+         << "Result = S.SubstExpr("
+         << "A->get" << getUpperName()
+         << "(), TemplateArgs, EarlySubstitution);\n";
       OS << "        if (Result.isInvalid())\n";
       OS << "          return nullptr;\n";
       OS << "        tempInst" << getUpperName() << " = Result.get();\n";
       OS << "      }\n";
     }
 
     void writeDump(raw_ostream &OS) const override {}
 
void writeTemplateInstantiation(raw_ostream &OS) const override {
          << "Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);\n";
       OS << "        " << getType() << " *TI = tempInst" << getUpperName()
          << ";\n";
       OS << "        " << getType() << " *I = A->" << getLowerName()
          << "_begin();\n";
       OS << "        " << getType() << " *E = A->" << getLowerName()
          << "_end();\n";
       OS << "        for (; I != E; ++I, ++TI) {\n";
-      OS << "          ExprResult Result = S.SubstExpr(*I, TemplateArgs);\n";
+      OS << "          ExprResult Result = S.SubstExpr(*I, TemplateArgs, "
+            "EarlySubstitution);\n";
       OS << "          if (Result.isInvalid())\n";
       OS << "            return nullptr;\n";
       OS << "          *TI = Result.get();\n";
       OS << "        }\n";
       OS << "      }\n";
     }
 
     void writeDump(raw_ostream &OS) const override {}
void writeASTVisitorTraversal(raw_ostream &OS) const override {
       OS << "  if (auto *TSI = A->get" << getUpperName() << "Loc())\n";
       OS << "    if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))\n";
       OS << "      return false;\n";
     }
 
     void writeTemplateInstantiation(raw_ostream &OS) const override {
       OS << "      " << getType() << " tempInst" << getUpperName() << " =\n";
       OS << "        S.SubstType(A->get" << getUpperName() << "Loc(), "
-         << "TemplateArgs, A->getLoc(), A->getAttrName());\n";
+         << "TemplateArgs, EarlySubstitution, A->getLoc(), A->getAttrName(), "
+         << "/*AllowDeducedTST=*/false);\n";
       OS << "      if (!tempInst" << getUpperName() << ")\n";
       OS << "        return nullptr;\n";
     }
 
     void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
       OS << "tempInst" << getUpperName();
     }
 
void EmitClangAttrTemplateInstantiate(RecordKeeper &Records, raw_ostream &OS) {
   emitSourceFileHeader("Template instantiation code for attributes", OS);
 
   std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
 
   OS << "namespace clang {\n"
      << "namespace sema {\n\n"
      << "Attr *instantiateTemplateAttribute(const Attr *At, ASTContext &C, "
      << "Sema &S,\n"
-     << "        const MultiLevelTemplateArgumentList &TemplateArgs) {\n";
+     << "        const MultiLevelTemplateArgumentList &TemplateArgs,\n"
+     << "        bool EarlySubstitution) {\n";
   EmitClangAttrTemplateInstantiateHelper(Attrs, OS, /*AppliesToDecl*/false);
   OS << "}\n\n"
      << "Attr *instantiateTemplateAttributeForDecl(const Attr *At,\n"
      << " ASTContext &C, Sema &S,\n"
-     << "        const MultiLevelTemplateArgumentList &TemplateArgs) {\n";
+     << "        const MultiLevelTemplateArgumentList &TemplateArgs,\n"
+     << "        bool EarlySubstitution) {\n";
   EmitClangAttrTemplateInstantiateHelper(Attrs, OS, /*AppliesToDecl*/true);
   OS << "}\n\n"
      << "} // end namespace sema\n"
      << "} // end namespace clang\n";
 }
 
 // Emits the list of parsed attributes.
 void EmitClangAttrParsedAttrList(RecordKeeper &Records, raw_ostream &OS) {