[clang] Set TypeSourceInfo for vardecl's in addition to type when we can deduce.

[kadircet]

rebase & ping

[aaron.ballman]

Can you give a bit more background on what problem you're trying to solve with this patch?

lib/Sema/SemaChecking.cpp

852 ↗

(On Diff #167718)

I'm not certain I understand why this code has been removed?

lib/Sema/SemaDecl.cpp

10772

Why does this need to return a pair? It seems like the returned TypeSourceInfo* carries all the information needed by the caller, or is there ever a case where the QualType will be different than what is returned by TypeSourceInfo::getType()?

[kadircet]

rebase

[kadircet]

In D52301#1263275, @aaron.ballman wrote:

Can you give a bit more background on what problem you're trying to solve with this patch?

Sorry for the lack of context, it was about an offline discussion on Sema::DeduceVariableDeclarationType just setting the type and not setting the typesourceinfo, which was resulting in having DeducedType in type but not in typesourceinfo.

We wanted to fix that behavior because it was resulting in getting "auto"s when we look at typesourceinfo(which happens in astprinter). But then it turned out to be there are other parts of clang(including extra tools) that depend on typesourceinfo not having the deduced type, for example include-fixer and refactoring/rename, relied on that information being missing when they were looking for (usage counts/locations) of symbols they were looking for.

So in the middle of the patch we were just trying to figure out whether we are going to break a big assumption that lots of different components relied on but just didn't had any tests for. Maybe @rsmith would have more context about the behavior?

lib/Sema/SemaChecking.cpp

852 ↗

(On Diff #167718)

It shouldn't have been, tried rebasing but it didn't go away. I think it was deleted at some point by a different change and somehow ended up showing in here as well. (Tried to revert, got an error stating warn_opencl_generic_address_space_arg doesn't exist)

lib/Sema/SemaDecl.cpp

10772

Yes, unfortunately there are cases these two differ. That's exactly the case we are trying to fix with that patch.

[shahms]

It's worth noting that RecursiveASTVisitor appears to think they are at least somewhat equivalent in that it will only visit one or the other and prefers TypeSourceInfo, if present, via VisitTypeLoc. The fact that the TSI lacks this information makes it pretty awkward to access both the recursively deduced type and the corresponding source location. It seems like the places that expect this information to be absent could be trivially updated to disregard it after this patch, but synthesizing this from the available AST is much more challenging.

[aaron.ballman]

Thank you for the context and explanation! I don't feel like I have enough familiarity with this machinery to be an effective reviewer for signing off on anything. I've commented with some nits, but @rsmith should give the sign-off on this one.

include/clang/AST/PrettyPrinter.h

229

prints deduced -> prints the deduced

230

Add a whitespace before the left paren.

include/clang/Sema/Sema.h

7063–7066

I'd appreciate some comments as to why this is returning a pair and under what circumstances the type information will be different, because it's not likely to be obvious to anyone reading this header.

lib/Frontend/ASTConsumers.cpp

92

Since -> Because

That said, I am not convinced I agree with this being the default. "Prettier" is pretty subjective, and I'd rather our default be for clarity instead of brevity, at least here.

lib/Sema/SemaChecking.cpp

852 ↗

(On Diff #167718)

That's truly strange. I bring it up because these sort of changes make it harder for reviewers to test changes locally by applying the patch themselves.

lib/Sema/SemaDecl.cpp

10912

Don't use auto as the type is not spelled out in the initialization.

lib/Sema/SemaStmt.cpp

1888

Formatting is off here (the * should bind to the right).

1975

Formatting.

3442–3443

Same -- you should probably run the patch through clang-format (https://clang.llvm.org/docs/ClangFormat.html#script-for-patch-reformatting).

lib/Sema/SemaTemplateDeduction.cpp

4464

Null check?

[ilya-biryukov]

A few more comments, mostly marking places of unintentional changes that we need to revert.
Hope it's not going past the point where the number of comments are not useful.

include/clang/Basic/DiagnosticSemaKinds.td

8616 ↗

(On Diff #166279)

This looks unintentional. Should we revert?

lib/Sema/SemaChecking.cpp

852 ↗

(On Diff #167718)

+1, we definitely need to revert this, happy to help figure out why this happened.

lib/Sema/SemaTemplateDeduction.cpp

4348–4349

Maybe remove the intermediate variable?

lib/Tooling/Refactoring/Rename/USRLocFinder.cpp

354 ↗

(On Diff #169885)

Why do we need this change? Are we fixing some particular regressions?
A comment would be useful.

test/SemaOpenCL/to_addr_builtin.cl

2 ↗

(On Diff #169885)

Unrelated change.

48 ↗

(On Diff #169885)

Unrelated change

122 ↗

(On Diff #169885)

Another unrelated change

[kadircet]

• Keep only relavant changes and rebase

[rsmith]

In D52301#1267163, @kadircet wrote:

So in the middle of the patch we were just trying to figure out whether we are going to break a big assumption that lots of different components relied on but just didn't had any tests for. Maybe @rsmith would have more context about the behavior?

We used to update the auto type in both the semantic type of the variable and in the type-as-written. I changed that in r180808; it was a while back, and I didn't do a good job explaining in the commit message, but I think the only reason was consistency. For the case of a deduced return type in a function, we really want to leave the type in the TypeSourceInfo alone, because we need to track the "declared return type" for redeclaration matching:

auto f() { return 0; }
int f(); // error
auto f(); // OK

As we need to sometimes track the "declared type" of the entity as distinct from the semantic type, and as the TypeSourceInfo is intended to track the type as written, it made sense to consistently not update the auto type in the type source information (so the TSI has the declared type, and getType() returns the semantic type).

That said... I'm definitely sympathetic to the problem. When using an AST matcher, for instance, we want to simultaneously think about matching certain syntactic source constructs (eg, match a TypeLoc) and then ask about the semantic properties of the type (for which you want to know what the deduced type was for an auto type). If we update the TypeSourceInfo for variables but not for functions, is that going to deliver the value you're looking for here, or should we be looking for some way to deal with cases where we want the TSI and type to differ and still want to be able to work out correspondences between them?

include/clang/AST/PrettyPrinter.h

: Indentation(2), SuppressSpecifiers(false),
       SuppressTemplateArgsInCXXConstructors(false),
       Bool(LO.Bool), Restrict(LO.C99),
       Alignof(LO.CPlusPlus11), UnderscoreAlignof(LO.C11),
       UseVoidForZeroParams(!LO.CPlusPlus),
       TerseOutput(false), PolishForDeclaration(false),
       Half(LO.Half), MSWChar(LO.MicrosoftExt && !LO.WChar),
       IncludeNewlines(true), MSVCFormatting(false),
       ConstantsAsWritten(false), SuppressImplicitBase(false),
-      FullyQualifiedName(false) { }
+      FullyQualifiedName(false), UseDeducedType(true) { }
 
   /// Adjust this printing policy for cases where it's known that we're
   /// printing C++ code (for instance, if AST dumping reaches a C++-only
   /// construct). This should not be used if a real LangOptions object is
   /// available.
   void adjustForCPlusPlus() {
     SuppressTagKeyword = true;
     Bool = true;
struct PrintingPolicy {
   unsigned ConstantsAsWritten : 1;
 
   /// When true, don't print the implicit 'self' or 'this' expressions.
   unsigned SuppressImplicitBase : 1;
 
   /// When true, print the fully qualified name of function declarations.
   /// This is the opposite of SuppressScope and thus overrules it.
   unsigned FullyQualifiedName : 1;
+
+  /// When true, prints deduced type for auto typed variables if their type has
+  /// been deduced. When false, always prints auto(or other variants e.g.
+  /// decltype(auto)) even if type was deduced.
+  unsigned UseDeducedType : 1;
 };
 
 } // end namespace clang
 
 #endif

include/clang/Sema/Sema.h

   /// Result type of DeduceAutoType.
   enum DeduceAutoResult {
     DAR_Succeeded,
     DAR_Failed,
     DAR_FailedAlreadyDiagnosed
   };
 
   DeduceAutoResult
-  DeduceAutoType(TypeSourceInfo *AutoType, Expr *&Initializer, QualType &Result,
+  DeduceAutoType(TypeSourceInfo *AutoType, Expr *&Initializer,
+                 TypeSourceInfo *&Result,
                  Optional<unsigned> DependentDeductionDepth = None);
   DeduceAutoResult
-  DeduceAutoType(TypeLoc AutoTypeLoc, Expr *&Initializer, QualType &Result,
+  DeduceAutoType(TypeLoc AutoTypeLoc, Expr *&Initializer,
+                 TypeSourceInfo *&Result,
                  Optional<unsigned> DependentDeductionDepth = None);
   void DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init);
   bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc,
                         bool Diagnose = true);
 
   /// Declare implicit deduction guides for a class template if we've
   /// not already done so.
   void DeclareImplicitDeductionGuides(TemplateDecl *Template,
                                       SourceLocation Loc);
 
   QualType DeduceTemplateSpecializationFromInitializer(
       TypeSourceInfo *TInfo, const InitializedEntity &Entity,
       const InitializationKind &Kind, MultiExprArg Init);
 
-  QualType deduceVarTypeFromInitializer(VarDecl *VDecl, DeclarationName Name,
-                                        QualType Type, TypeSourceInfo *TSI,
-                                        SourceRange Range, bool DirectInit,
-                                        Expr *Init);
+  std::pair<QualType, TypeSourceInfo *>
+  deduceVarTypeFromInitializer(VarDecl *VDecl, DeclarationName Name,
+                               SourceRange Range, bool DirectInit, Expr *Init);
 
   TypeLoc getReturnTypeLoc(FunctionDecl *FD) const;
 
   bool DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD,
                                         SourceLocation ReturnLoc,
                                         Expr *&RetExpr, AutoType *AT);
 
   FunctionTemplateDecl *getMoreSpecializedTemplate(FunctionTemplateDecl *FT1,

lib/AST/TypePrinter.cpp

case UnaryTransformType::EnumUnderlyingType:
       return;
   }
 
   printAfter(T->getBaseType(), OS);
 }
 
 void TypePrinter::printAutoBefore(const AutoType *T, raw_ostream &OS) {
   // If the type has been deduced, do not print 'auto'.
-  if (!T->getDeducedType().isNull()) {
+  if (Policy.UseDeducedType && !T->getDeducedType().isNull()) {
     printBefore(T->getDeducedType(), OS);
   } else {
     switch (T->getKeyword()) {
     case AutoTypeKeyword::Auto: OS << "auto"; break;
     case AutoTypeKeyword::DecltypeAuto: OS << "decltype(auto)"; break;
     case AutoTypeKeyword::GNUAutoType: OS << "__auto_type"; break;
     }
     spaceBeforePlaceHolder(OS);
   }
 }
 
 void TypePrinter::printAutoAfter(const AutoType *T, raw_ostream &OS) {
   // If the type has been deduced, do not print 'auto'.
-  if (!T->getDeducedType().isNull())
+  if (Policy.UseDeducedType && !T->getDeducedType().isNull())
     printAfter(T->getDeducedType(), OS);
 }
 
 void TypePrinter::printDeducedTemplateSpecializationBefore(
     const DeducedTemplateSpecializationType *T, raw_ostream &OS) {
   // If the type has been deduced, print the deduced type.
   if (!T->getDeducedType().isNull()) {
     printBefore(T->getDeducedType(), OS);

lib/Frontend/ASTConsumers.cpp

void print(Decl *D) {
             DC->dumpLookups(Out, OutputKind != None, OutputKind == DumpFull);
           else
             Out << "Lookup map is in primary DeclContext "
                 << DC->getPrimaryContext() << "\n";
         } else
           Out << "Not a DeclContext\n";
       } else if (OutputKind == Print) {
         PrintingPolicy Policy(D->getASTContext().getLangOpts());
+        // Since ASTPrinter is used for pretty printing and auto is generally
+        // prettier than real type itself, we'll choose to print auto always.
+        Policy.UseDeducedType = false;
         D->print(Out, Policy, /*Indentation=*/0, /*PrintInstantiation=*/true);
       } else if (OutputKind != None)
         D->dump(Out, OutputKind == DumpFull);
     }
 
     raw_ostream &Out;
     std::unique_ptr<raw_ostream> OwnedOut;
 

lib/Sema/SemaDecl.cpp

struct VarDeclOrName {
 
     friend const Sema::SemaDiagnosticBuilder &
     operator<<(const Sema::SemaDiagnosticBuilder &Diag, VarDeclOrName VN) {
       return VN.VDecl ? Diag << VN.VDecl : Diag << VN.Name;
     }
   };
 } // end anonymous namespace
 
-QualType Sema::deduceVarTypeFromInitializer(VarDecl *VDecl,
+std::pair<QualType, TypeSourceInfo*> Sema::deduceVarTypeFromInitializer(VarDecl *VDecl,
                                             DeclarationName Name, QualType Type,
                                             TypeSourceInfo *TSI,
                                             SourceRange Range, bool DirectInit,
                                             Expr *Init) {
   bool IsInitCapture = !VDecl;
   assert((!VDecl || !VDecl->isInitCapture()) &&
          "init captures are expected to be deduced prior to initialization");
 
   VarDeclOrName VN{VDecl, Name};
 
   DeducedType *Deduced = Type->getContainedDeducedType();
   assert(Deduced && "deduceVarTypeFromInitializer for non-deduced type");
 
   // C++11 [dcl.spec.auto]p3
   if (!Init) {
     assert(VDecl && "no init for init capture deduction?");
 
     // Except for class argument deduction, and then for an initializing
     // declaration only, i.e. no static at class scope or extern.
     if (!isa<DeducedTemplateSpecializationType>(Deduced) ||
         VDecl->hasExternalStorage() ||
         VDecl->isStaticDataMember()) {
       Diag(VDecl->getLocation(), diag::err_auto_var_requires_init)
         << VDecl->getDeclName() << Type;
-      return QualType();
+      return {QualType(), nullptr};
     }
   }
 
   ArrayRef<Expr*> DeduceInits;
   if (Init)
     DeduceInits = Init;
 
   if (DirectInit) {
     if (auto *PL = dyn_cast_or_null<ParenListExpr>(Init))
       DeduceInits = PL->exprs();
   }
 
   if (isa<DeducedTemplateSpecializationType>(Deduced)) {
     assert(VDecl && "non-auto type for init capture deduction?");
     InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl);
     InitializationKind Kind = InitializationKind::CreateForInit(
         VDecl->getLocation(), DirectInit, Init);
     // FIXME: Initialization should not be taking a mutable list of inits.
     SmallVector<Expr*, 8> InitsCopy(DeduceInits.begin(), DeduceInits.end());
-    return DeduceTemplateSpecializationFromInitializer(TSI, Entity, Kind,
-                                                       InitsCopy);
+    return {DeduceTemplateSpecializationFromInitializer(TSI, Entity, Kind,
+                                                       InitsCopy), nullptr};
   }
 
   if (DirectInit) {
     if (auto *IL = dyn_cast<InitListExpr>(Init))
       DeduceInits = IL->inits();
   }
 
   // Deduction only works if we have exactly one source expression.
   if (DeduceInits.empty()) {
     // It isn't possible to write this directly, but it is possible to
     // end up in this situation with "auto x(some_pack...);"
     Diag(Init->getBeginLoc(), IsInitCapture
                                   ? diag::err_init_capture_no_expression
                                   : diag::err_auto_var_init_no_expression)
         << VN << Type << Range;
-    return QualType();
+    return {QualType(), nullptr};
   }
 
   if (DeduceInits.size() > 1) {
     Diag(DeduceInits[1]->getBeginLoc(),
          IsInitCapture ? diag::err_init_capture_multiple_expressions
                        : diag::err_auto_var_init_multiple_expressions)
         << VN << Type << Range;
-    return QualType();
+    return {QualType(), nullptr};
   }
 
   Expr *DeduceInit = DeduceInits[0];
   if (DirectInit && isa<InitListExpr>(DeduceInit)) {
     Diag(Init->getBeginLoc(), IsInitCapture
                                   ? diag::err_init_capture_paren_braces
                                   : diag::err_auto_var_init_paren_braces)
         << isa<InitListExpr>(Init) << VN << Type << Range;
-    return QualType();
+    return {QualType(), nullptr};
   }
 
   // Expressions default to 'id' when we're in a debugger.
   bool DefaultedAnyToId = false;
   if (getLangOpts().DebuggerCastResultToId &&
       Init->getType() == Context.UnknownAnyTy && !IsInitCapture) {
     ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType());
     if (Result.isInvalid()) {
-      return QualType();
+      return {QualType(), nullptr};
     }
     Init = Result.get();
     DefaultedAnyToId = true;
   }
 
   // C++ [dcl.decomp]p1:
   //   If the assignment-expression [...] has array type A and no ref-qualifier
   //   is present, e has type cv A
   if (VDecl && isa<DecompositionDecl>(VDecl) &&
       Context.hasSameUnqualifiedType(Type, Context.getAutoDeductType()) &&
       DeduceInit->getType()->isConstantArrayType())
-    return Context.getQualifiedType(DeduceInit->getType(),
-                                    Type.getQualifiers());
+    return {Context.getQualifiedType(DeduceInit->getType(),
+                                    Type.getQualifiers()), nullptr};
 
-  QualType DeducedType;
-  if (DeduceAutoType(TSI, DeduceInit, DeducedType) == DAR_Failed) {
+  TypeSourceInfo* DeducedTypeTSI = nullptr;
+  if (DeduceAutoType(TSI, DeduceInit, DeducedTypeTSI) == DAR_Failed) {
     if (!IsInitCapture)
       DiagnoseAutoDeductionFailure(VDecl, DeduceInit);
     else if (isa<InitListExpr>(Init))
       Diag(Range.getBegin(),
            diag::err_init_capture_deduction_failure_from_init_list)
           << VN
           << (DeduceInit->getType().isNull() ? TSI->getType()
                                              : DeduceInit->getType())
           << DeduceInit->getSourceRange();
     else
       Diag(Range.getBegin(), diag::err_init_capture_deduction_failure)
           << VN << TSI->getType()
           << (DeduceInit->getType().isNull() ? TSI->getType()
                                              : DeduceInit->getType())
           << DeduceInit->getSourceRange();
   }
 
   // Warn if we deduced 'id'. 'auto' usually implies type-safety, but using
   // 'id' instead of a specific object type prevents most of our usual
   // checks.
   // We only want to warn outside of template instantiations, though:
   // inside a template, the 'id' could have come from a parameter.
   if (!inTemplateInstantiation() && !DefaultedAnyToId && !IsInitCapture &&
-      !DeducedType.isNull() && DeducedType->isObjCIdType()) {
+      DeducedTypeTSI && !DeducedTypeTSI->getType().isNull() &&
+      DeducedTypeTSI->getType()->isObjCIdType()) {
     SourceLocation Loc = TSI->getTypeLoc().getBeginLoc();
     Diag(Loc, diag::warn_auto_var_is_id) << VN << Range;
   }
 
-  return DeducedType;
+  return {DeducedTypeTSI ? DeducedTypeTSI->getType() : QualType(),
+          DeducedTypeTSI};
 }
 
 bool Sema::DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit,
                                          Expr *Init) {
-  QualType DeducedType = deduceVarTypeFromInitializer(
+  auto DeducedTypeAndTSI = deduceVarTypeFromInitializer(
       VDecl, VDecl->getDeclName(), VDecl->getType(), VDecl->getTypeSourceInfo(),
       VDecl->getSourceRange(), DirectInit, Init);
-  if (DeducedType.isNull()) {
+  if (DeducedTypeAndTSI.first.isNull()) {
     VDecl->setInvalidDecl();
     return true;
   }
 
-  VDecl->setType(DeducedType);
+  VDecl->setType(DeducedTypeAndTSI.first);
+  if (DeducedTypeAndTSI.second)
+    VDecl->setTypeSourceInfo(DeducedTypeAndTSI.second);
   assert(VDecl->isLinkageValid());
 
   // In ARC, infer lifetime.
   if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(VDecl))
     VDecl->setInvalidDecl();
 
   // If this is a redeclaration, check that the type we just deduced matches
   // the previously declared type.

lib/Sema/SemaExprCXX.cpp

if (NumInits > 1) {
       return ExprError(Diag(FirstBad->getBeginLoc(),
                             diag::err_auto_new_ctor_multiple_expressions)
                        << AllocType << TypeRange);
     }
     if (Braced && !getLangOpts().CPlusPlus17)
       Diag(Initializer->getBeginLoc(), diag::ext_auto_new_list_init)
           << AllocType << TypeRange;
     Expr *Deduce = Inits[0];
-    QualType DeducedType;
-    if (DeduceAutoType(AllocTypeInfo, Deduce, DeducedType) == DAR_Failed)
+    TypeSourceInfo* DeducedTypeTSI = nullptr;
+    if (DeduceAutoType(AllocTypeInfo, Deduce, DeducedTypeTSI) == DAR_Failed)
       return ExprError(Diag(StartLoc, diag::err_auto_new_deduction_failure)
                        << AllocType << Deduce->getType()
                        << TypeRange << Deduce->getSourceRange());
-    if (DeducedType.isNull())
+    if (DeducedTypeTSI->getType().isNull())
       return ExprError();
-    AllocType = DeducedType;
+    AllocType = DeducedTypeTSI->getType();
   }
 
   // Per C++0x [expr.new]p5, the type being constructed may be a
   // typedef of an array type.
   if (!ArraySize) {
     if (const ConstantArrayType *Array
                               = Context.getAsConstantArrayType(AllocType)) {
       ArraySize = IntegerLiteral::Create(Context, Array->getSize(),

lib/Sema/SemaLambda.cpp

if (ByRef) {
     assert(!DeductType.isNull() && "can't build reference to auto");
     TLB.push<ReferenceTypeLoc>(DeductType).setSigilLoc(Loc);
   }
   TypeSourceInfo *TSI = TLB.getTypeSourceInfo(Context, DeductType);
 
   // Deduce the type of the init capture.
   QualType DeducedType = deduceVarTypeFromInitializer(
       /*VarDecl*/nullptr, DeclarationName(Id), DeductType, TSI,
-      SourceRange(Loc, Loc), IsDirectInit, Init);
+      SourceRange(Loc, Loc), IsDirectInit, Init).first;
   if (DeducedType.isNull())
     return QualType();
 
   // Are we a non-list direct initialization?
   ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init);
 
   // Perform initialization analysis and ensure any implicit conversions
   // (such as lvalue-to-rvalue) are enforced.

lib/Sema/SemaStmt.cpp

Sema::ActOnObjCForCollectionStmt(SourceLocation ForLoc,
                                  Stmt *First, Expr *collection,
                                  SourceLocation RParenLoc) {
   setFunctionHasBranchProtectedScope();
 
   ExprResult CollectionExprResult =
     CheckObjCForCollectionOperand(ForLoc, collection);
 
   if (First) {
-    QualType FirstType;
+    TypeSourceInfo* FirstTypeTSI;
     if (DeclStmt *DS = dyn_cast<DeclStmt>(First)) {
       if (!DS->isSingleDecl())
         return StmtError(Diag((*DS->decl_begin())->getLocation(),
                          diag::err_toomany_element_decls));
 
       VarDecl *D = dyn_cast<VarDecl>(DS->getSingleDecl());
       if (!D || D->isInvalidDecl())
         return StmtError();
 
-      FirstType = D->getType();
+      FirstTypeTSI = D->getTypeSourceInfo();
       // C99 6.8.5p3: The declaration part of a 'for' statement shall only
       // declare identifiers for objects having storage class 'auto' or
       // 'register'.
       if (!D->hasLocalStorage())
         return StmtError(Diag(D->getLocation(),
                               diag::err_non_local_variable_decl_in_for));
 
       // If the type contained 'auto', deduce the 'auto' to 'id'.
-      if (FirstType->getContainedAutoType()) {
+      if (FirstTypeTSI->getType()->getContainedAutoType()) {
         OpaqueValueExpr OpaqueId(D->getLocation(), Context.getObjCIdType(),
                                  VK_RValue);
         Expr *DeducedInit = &OpaqueId;
-        if (DeduceAutoType(D->getTypeSourceInfo(), DeducedInit, FirstType) ==
+        if (DeduceAutoType(D->getTypeSourceInfo(), DeducedInit, FirstTypeTSI) ==
                 DAR_Failed)
           DiagnoseAutoDeductionFailure(D, DeducedInit);
-        if (FirstType.isNull()) {
+        if (FirstTypeTSI->getType().isNull()) {
           D->setInvalidDecl();
           return StmtError();
         }
 
-        D->setType(FirstType);
+        D->setType(FirstTypeTSI->getType());
 
         if (!inTemplateInstantiation()) {
           SourceLocation Loc =
               D->getTypeSourceInfo()->getTypeLoc().getBeginLoc();
           Diag(Loc, diag::warn_auto_var_is_id)
             << D->getDeclName();
         }
       }
 
     } else {
       Expr *FirstE = cast<Expr>(First);
       if (!FirstE->isTypeDependent() && !FirstE->isLValue())
         return StmtError(
             Diag(First->getBeginLoc(), diag::err_selector_element_not_lvalue)
             << First->getSourceRange());
 
-      FirstType = static_cast<Expr*>(First)->getType();
+      QualType FirstType = static_cast<Expr*>(First)->getType();
       if (FirstType.isConstQualified())
         Diag(ForLoc, diag::err_selector_element_const_type)
           << FirstType << First->getSourceRange();
+      FirstTypeTSI = this->Context.getTrivialTypeSourceInfo(FirstType);
     }
-    if (!FirstType->isDependentType() &&
-        !FirstType->isObjCObjectPointerType() &&
-        !FirstType->isBlockPointerType())
+    if (!FirstTypeTSI->getType()->isDependentType() &&
+        !FirstTypeTSI->getType()->isObjCObjectPointerType() &&
+        !FirstTypeTSI->getType()->isBlockPointerType())
         return StmtError(Diag(ForLoc, diag::err_selector_element_type)
-                           << FirstType << First->getSourceRange());
+                           << FirstTypeTSI->getType() << First->getSourceRange());
   }
 
   if (CollectionExprResult.isInvalid())
     return StmtError();
 
   CollectionExprResult = ActOnFinishFullExpr(CollectionExprResult.get());
   if (CollectionExprResult.isInvalid())
     return StmtError();
if (!Res.isUsable()) {
       Decl->setInvalidDecl();
       return true;
     }
     Init = Res.get();
   }
 
   // Deduce the type for the iterator variable now rather than leaving it to
   // AddInitializerToDecl, so we can produce a more suitable diagnostic.
-  QualType InitType;
+  TypeSourceInfo* InitTypeTSI = nullptr;
   if ((!isa<InitListExpr>(Init) && Init->getType()->isVoidType()) ||
-      SemaRef.DeduceAutoType(Decl->getTypeSourceInfo(), Init, InitType) ==
+      SemaRef.DeduceAutoType(Decl->getTypeSourceInfo(), Init, InitTypeTSI) ==
           Sema::DAR_Failed)
     SemaRef.Diag(Loc, DiagID) << Init->getType();
-  if (InitType.isNull()) {
+  if (!InitTypeTSI || InitTypeTSI->getType().isNull()) {
     Decl->setInvalidDecl();
     return true;
   }
-  Decl->setType(InitType);
+  Decl->setType(InitTypeTSI->getType());
+  Decl->setTypeSourceInfo(InitTypeTSI);
 
   // In ARC, infer lifetime.
   // FIXME: ARC may want to turn this into 'const __unsafe_unretained' if
   // we're doing the equivalent of fast iteration.
   if (SemaRef.getLangOpts().ObjCAutoRefCount &&
       SemaRef.inferObjCARCLifetime(Decl))
     Decl->setInvalidDecl();
 
if (FD->isDependentContext()) {
     //   statement with a non-type-dependent operand.
     assert(AT->isDeduced() && "should have deduced to dependent type");
     return false;
   }
 
   if (RetExpr) {
     //  Otherwise, [...] deduce a value for U using the rules of template
     //  argument deduction.
-    DeduceAutoResult DAR = DeduceAutoType(OrigResultType, RetExpr, Deduced);
+    TypeSourceInfo* DeducedTSI = nullptr;
+    DeduceAutoResult DAR = DeduceAutoType(OrigResultType, RetExpr, DeducedTSI);
 
     if (DAR == DAR_Failed && !FD->isInvalidDecl())
       Diag(RetExpr->getExprLoc(), diag::err_auto_fn_deduction_failure)
         << OrigResultType.getType() << RetExpr->getType();
 
     if (DAR != DAR_Succeeded)
       return true;
 
     // If a local type is part of the returned type, mark its fields as
     // referenced.
     LocalTypedefNameReferencer Referencer(*this);
     Referencer.TraverseType(RetExpr->getType());
+    Deduced = DeducedTSI->getType();
   } else {
     //  In the case of a return with no operand, the initializer is considered
     //  to be void().
     //
     // Deduction here can only succeed if the return type is exactly 'cv auto'
     // or 'decltype(auto)', so just check for that case directly.
     if (!OrigResultType.getType()->getAs<AutoType>()) {
       Diag(ReturnLoc, diag::err_auto_fn_return_void_but_not_auto)

lib/Sema/SemaTemplate.cpp

if (getLangOpts().CPlusPlus17 && ParamType->isUndeducedType()) {
     }
 
     // When checking a deduced template argument, deduce from its type even if
     // the type is dependent, in order to check the types of non-type template
     // arguments line up properly in partial ordering.
     Optional<unsigned> Depth;
     if (CTAK != CTAK_Specified)
       Depth = Param->getDepth() + 1;
+    TypeSourceInfo *ParamTypeTSI = nullptr;
     if (DeduceAutoType(
             Context.getTrivialTypeSourceInfo(ParamType, Param->getLocation()),
-            Arg, ParamType, Depth) == DAR_Failed) {
+            Arg, ParamTypeTSI, Depth) == DAR_Failed) {
       Diag(Arg->getExprLoc(),
            diag::err_non_type_template_parm_type_deduction_failure)
         << Param->getDeclName() << Param->getType() << Arg->getType()
         << Arg->getSourceRange();
       Diag(Param->getLocation(), diag::note_template_param_here);
       return ExprError();
     }
     // CheckNonTypeTemplateParameterType will produce a diagnostic if there's
     // an error. The error message normally references the parameter
     // declaration, but here we'll pass the argument location because that's
     // where the parameter type is deduced.
-    ParamType = CheckNonTypeTemplateParameterType(ParamType, Arg->getExprLoc());
+    ParamType = CheckNonTypeTemplateParameterType(ParamTypeTSI->getType(),
+                                                  Arg->getExprLoc());
     if (ParamType.isNull()) {
       Diag(Param->getLocation(), diag::note_template_param_here);
       return ExprError();
     }
   }
 
   // We should have already dropped all cv-qualifiers by now.
   assert(!ParamType.hasQualifiers() &&

lib/Sema/SemaTemplateDeduction.cpp

QualType TransformDeducedTemplateSpecializationType(
       return Result;
     }
 
     ExprResult TransformLambdaExpr(LambdaExpr *E) {
       // Lambdas never need to be transformed.
       return E;
     }
 
-    QualType Apply(TypeLoc TL) {
+    TypeSourceInfo* Apply(TypeLoc TL) {
       // Create some scratch storage for the transformed type locations.
       // FIXME: We're just going to throw this information away. Don't build it.
       TypeLocBuilder TLB;
       TLB.reserve(TL.getFullDataSize());
-      return TransformType(TLB, TL);
+      QualType Result = TransformType(TLB, TL);
+      return TLB.getTypeSourceInfo(getSema().Context, Result);
     }
   };
 
 } // namespace
 
 Sema::DeduceAutoResult
-Sema::DeduceAutoType(TypeSourceInfo *Type, Expr *&Init, QualType &Result,
+Sema::DeduceAutoType(TypeSourceInfo *Type, Expr *&Init, TypeSourceInfo *&Result,
                      Optional<unsigned> DependentDeductionDepth) {
   return DeduceAutoType(Type->getTypeLoc(), Init, Result,
                         DependentDeductionDepth);
 }
 
 /// Attempt to produce an informative diagostic explaining why auto deduction
 /// failed.
 /// \return \c true if diagnosed, \c false if not.

 /// \param Init the initializer for the variable whose type is to be deduced.
 /// \param Result if type deduction was successful, this will be set to the
 ///        deduced type.
 /// \param DependentDeductionDepth Set if we should permit deduction in
 ///        dependent cases. This is necessary for template partial ordering with
 ///        'auto' template parameters. The value specified is the template
 ///        parameter depth at which we should perform 'auto' deduction.
 Sema::DeduceAutoResult
-Sema::DeduceAutoType(TypeLoc Type, Expr *&Init, QualType &Result,
+Sema::DeduceAutoType(TypeLoc Type, Expr *&Init, TypeSourceInfo *&Result,
                      Optional<unsigned> DependentDeductionDepth) {
   if (Init->getType()->isNonOverloadPlaceholderType()) {
     ExprResult NonPlaceholder = CheckPlaceholderExpr(Init);
     if (NonPlaceholder.isInvalid())
       return DAR_FailedAlreadyDiagnosed;
     Init = NonPlaceholder.get();
   }
 
   if (!DependentDeductionDepth &&
       (Type.getType()->isDependentType() || Init->isTypeDependent())) {
     Result = SubstituteDeducedTypeTransform(*this, QualType()).Apply(Type);
-    assert(!Result.isNull() && "substituting DependentTy can't fail");
+    assert(Result && !Result->getType().isNull() &&
+           "substituting DependentTy can't fail");
     return DAR_Succeeded;
   }
 
   // Find the depth of template parameter to synthesize.
   unsigned Depth = DependentDeductionDepth.getValueOr(0);
 
   // If this is a 'decltype(auto)' specifier, do the decltype dance.
   // Since 'decltype(auto)' can only occur at the top of the type, we
   // don't need to go digging for it.
   if (const AutoType *AT = Type.getType()->getAs<AutoType>()) {
     if (AT->isDecltypeAuto()) {
       if (isa<InitListExpr>(Init)) {
         Diag(Init->getBeginLoc(), diag::err_decltype_auto_initializer_list);
         return DAR_FailedAlreadyDiagnosed;
       }
 
       QualType Deduced = BuildDecltypeType(Init, Init->getBeginLoc(), false);
       if (Deduced.isNull())
         return DAR_FailedAlreadyDiagnosed;
       // FIXME: Support a non-canonical deduced type for 'auto'.
       Deduced = Context.getCanonicalType(Deduced);
       Result = SubstituteDeducedTypeTransform(*this, Deduced).Apply(Type);
-      if (Result.isNull())
+      if (!Result || Result->getType().isNull())
         return DAR_FailedAlreadyDiagnosed;
       return DAR_Succeeded;
     } else if (!getLangOpts().CPlusPlus) {
       if (isa<InitListExpr>(Init)) {
         Diag(Init->getBeginLoc(), diag::err_auto_init_list_from_c);
         return DAR_FailedAlreadyDiagnosed;
       }
     }
   }
 
   SourceLocation Loc = Init->getExprLoc();
 
   LocalInstantiationScope InstScope(*this);
 
   // Build template<class TemplParam> void Func(FuncParam);
   TemplateTypeParmDecl *TemplParam = TemplateTypeParmDecl::Create(
       Context, nullptr, SourceLocation(), Loc, Depth, 0, nullptr, false, false);
   QualType TemplArg = QualType(TemplParam->getTypeForDecl(), 0);
   NamedDecl *TemplParamPtr = TemplParam;
   FixedSizeTemplateParameterListStorage<1, false> TemplateParamsSt(
       Loc, Loc, TemplParamPtr, Loc, nullptr);
 
-  QualType FuncParam =
-      SubstituteDeducedTypeTransform(*this, TemplArg, /*UseTypeSugar*/false)
+  TypeSourceInfo *FuncParamTSI =
+      SubstituteDeducedTypeTransform(*this, TemplArg, /*UseTypeSugar*/ false)
           .Apply(Type);
-  assert(!FuncParam.isNull() &&
+  assert(!FuncParamTSI->getType().isNull() &&
          "substituting template parameter for 'auto' failed");
 
   // Deduce type of TemplParam in Func(Init)
   SmallVector<DeducedTemplateArgument, 1> Deduced;
   Deduced.resize(1);
 
   TemplateDeductionInfo Info(Loc, Depth);
 
   // If deduction failed, don't diagnose if the initializer is dependent; it
   // might acquire a matching type in the instantiation.
   auto DeductionFailed = [&](TemplateDeductionResult TDK,
                              ArrayRef<SourceRange> Ranges) -> DeduceAutoResult {
     if (Init->isTypeDependent()) {
       Result = SubstituteDeducedTypeTransform(*this, QualType()).Apply(Type);
-      assert(!Result.isNull() && "substituting DependentTy can't fail");
+      assert(Result && !Result->getType().isNull() &&
+             "substituting DependentTy can't fail");
       return DAR_Succeeded;
     }
     if (diagnoseAutoDeductionFailure(*this, TDK, Info, Ranges))
       return DAR_FailedAlreadyDiagnosed;
     return DAR_Failed;
   };
 
   SmallVector<OriginalCallArg, 4> OriginalCallArgs;
if (InitList) {
     }
   } else {
     if (!getLangOpts().CPlusPlus && Init->refersToBitField()) {
       Diag(Loc, diag::err_auto_bitfield);
       return DAR_FailedAlreadyDiagnosed;
     }
 
     if (auto TDK = DeduceTemplateArgumentsFromCallArgument(
-            *this, TemplateParamsSt.get(), 0, FuncParam, Init, Info, Deduced,
-            OriginalCallArgs, /*Decomposed*/ false, /*ArgIdx*/ 0, /*TDF*/ 0))
+            *this, TemplateParamsSt.get(), 0, FuncParamTSI->getType(), Init,
+            Info, Deduced, OriginalCallArgs, /*Decomposed*/ false, /*ArgIdx*/ 0,
+            /*TDF*/ 0))
       return DeductionFailed(TDK, {});
   }
 
   // Could be null if somehow 'auto' appears in a non-deduced context.
   if (Deduced[0].getKind() != TemplateArgument::Type)
     return DeductionFailed(TDK_Incomplete, {});
 
   QualType DeducedType = Deduced[0].getAsType();
 
   if (InitList) {
     DeducedType = BuildStdInitializerList(DeducedType, Loc);
     if (DeducedType.isNull())
       return DAR_FailedAlreadyDiagnosed;
   }
 
   Result = SubstituteDeducedTypeTransform(*this, DeducedType).Apply(Type);
-  if (Result.isNull())
+  if (!Result || Result->getType().isNull())
     return DAR_FailedAlreadyDiagnosed;
 
   // Check that the deduced argument type is compatible with the original
   // argument type per C++ [temp.deduct.call]p4.
-  QualType DeducedA = InitList ? Deduced[0].getAsType() : Result;
+  QualType DeducedA = InitList ? Deduced[0].getAsType() : Result->getType();
   for (const OriginalCallArg &OriginalArg : OriginalCallArgs) {
     assert((bool)InitList == OriginalArg.DecomposedParam &&
            "decomposed non-init-list in auto deduction?");
     if (auto TDK =
             CheckOriginalCallArgDeduction(*this, Info, OriginalArg, DeducedA)) {
-      Result = QualType();
+      Result = nullptr;
       return DeductionFailed(TDK, {});
     }
   }
 
   return DAR_Succeeded;
 }
 
 QualType Sema::SubstAutoType(QualType TypeWithAuto,