[Sema] Store deduced type in TypeLoc

[ilya-biryukov]

Summary

This greatly simplifies source-level tools that need to know what 'auto'
deduced to, e.g. clangd.

Also change default presentation of such types to print 'auto' instead
of the deduced type. To print the deduced types, one shoould set the
PrintingPolicy::Flag to true.

[ilya-biryukov]

This produces the following test failures after running check-clang:

Failing Tests (4):                                                                                                                                                                                                 
    Clang :: CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.class.deduct/p1.cpp                                                                                                                                            
    Clang :: SemaCXX/cxx1z-class-template-argument-deduction.cpp                                                                                                                                                   
    Clang-Unit :: Rename/./ClangRenameTests/RenameClassTests/RenameClassTest.RenameClasses/34                                                                                                                      
    Clang-Unit :: Rename/./ClangRenameTests/RenameEnumTests/RenameEnumTest.RenameEnums/7

All 4 are source-location and declaration-printing-related. Could probably be fixed.
Putting the change here, so that it does not get lost, but I've spent my time budget on this (at least for now).

[merge_guards_bot]

Unit tests: fail. 61166 tests passed, 9 failed and 729 were skipped.

failed: Clang.CXX/dcl_dcl/dcl_spec/dcl_type/dcl_type_class_deduct/p1.cpp
failed: Clang.SemaCXX/cxx1z-class-template-argument-deduction.cpp
failed: Clang-Unit.Rename/_/ClangRenameTests/RenameClassTests/RenameClassTest.RenameClasses/34
failed: Clang-Unit.Rename/_/ClangRenameTests/RenameEnumTests/RenameEnumTest.RenameEnums/7
failed: Clangd Unit Tests._/ClangdTests/Hover.NoHover
failed: Clangd Unit Tests._/ClangdTests/SymbolInfoTests.All
failed: Clangd Unit Tests._/ClangdTests/TargetDeclTest.Lambda
failed: Clangd Unit Tests._/ClangdTests/TargetDeclTest.Types
failed: Extra Tools Unit Tests.clang-include-fixer/find-all-symbols/_/FindAllSymbolsTests/FindAllSymbolsTest.EnumTest

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

clang/include/clang/AST/PrettyPrinter.h

PrintingPolicy(const LangOptions &LO)
         SuppressLifetimeQualifiers(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),
-        PrintCanonicalTypes(false) {}
+        PrintCanonicalTypes(false), ExpandDeducedTypes(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 {
 
   /// When true, print the fully qualified name of function declarations.
   /// This is the opposite of SuppressScope and thus overrules it.
   unsigned FullyQualifiedName : 1;
 
   /// Whether to print types as written or canonically.
   unsigned PrintCanonicalTypes : 1;
 
+  /// Whether to print the deduced types instead of their original spelling,
+  /// e.g. when set to true will print
+  ///   int x = 1;
+  /// even if the original code was:
+  ///   auto x = 1;
+  /// When set to false, will always print:
+  ///   auto x = 1;
+  unsigned ExpandDeducedTypes : 1;
+
   /// Callbacks to use to allow the behavior of printing to be customized.
   const PrintingCallbacks *Callbacks = nullptr;
 };
 
 } // end namespace clang
 
 #endif

clang/include/clang/Sema/Sema.h

 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/ExternalASTSource.h"
 #include "clang/AST/LocInfoType.h"
 #include "clang/AST/MangleNumberingContext.h"
 #include "clang/AST/NSAPI.h"
 #include "clang/AST/PrettyPrinter.h"
 #include "clang/AST/StmtCXX.h"
+#include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/AST/TypeOrdering.h"
 #include "clang/Basic/BitmaskEnum.h"
 #include "clang/Basic/ExpressionTraits.h"
 #include "clang/Basic/Module.h"
 #include "clang/Basic/OpenMPKinds.h"
 #include "clang/Basic/PragmaKinds.h"
 #include "clang/Basic/Specifiers.h"

   /// Result type of DeduceAutoType.
   enum DeduceAutoResult {
     DAR_Succeeded,
     DAR_Failed,
     DAR_FailedAlreadyDiagnosed
   };
 
   DeduceAutoResult
-  DeduceAutoType(TypeSourceInfo *AutoType, Expr *&Initializer, QualType &Result,
-                 Optional<unsigned> DependentDeductionDepth = None);
-  DeduceAutoResult
-  DeduceAutoType(TypeLoc AutoTypeLoc, Expr *&Initializer, QualType &Result,
+  DeduceAutoType(TypeSourceInfo *AutoTSI, 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);
+  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,

clang/lib/AST/DeclPrinter.cpp

 void DeclPrinter::printDeclType(QualType T, StringRef DeclName, bool Pack) {
   // Normally, a PackExpansionType is written as T[3]... (for instance, as a
   // template argument), but if it is the type of a declaration, the ellipsis
   // is placed before the name being declared.
   if (auto *PET = T->getAs<PackExpansionType>()) {
     Pack = true;
     T = PET->getPattern();
   }
-  T.print(Out, Policy, (Pack ? "..." : "") + DeclName, Indentation);
+  auto NoDeduced = Policy;
+  NoDeduced.ExpandDeducedTypes = false;
+  T.print(Out, NoDeduced, (Pack ? "..." : "") + DeclName, Indentation);
 }
 
 void DeclPrinter::ProcessDeclGroup(SmallVectorImpl<Decl*>& Decls) {
   this->Indent();
   Decl::printGroup(Decls.data(), Decls.size(), Out, Policy, Indentation);
   Out << ";\n";
   Decls.clear();
 

clang/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 (!T->getDeducedType().isNull() && Policy.ExpandDeducedTypes) {
     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 (!T->getDeducedType().isNull() && Policy.ExpandDeducedTypes)
     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);

clang/lib/Sema/SemaDecl.cpp

 #include "clang/AST/CommentDiagnostic.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/EvaluatedExprVisitor.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/NonTrivialTypeVisitor.h"
 #include "clang/AST/StmtCXX.h"
+#include "clang/AST/Type.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/HeaderSearch.h" // TODO: Sema shouldn't depend on Lex
 #include "clang/Lex/Lexer.h" // TODO: Extract static functions to fix layering.
 #include "clang/Lex/ModuleLoader.h" // TODO: Sema shouldn't depend on Lex
 #include "clang/Lex/Preprocessor.h" // Included for isCodeCompletionEnabled()
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,
-                                            DeclarationName Name, QualType Type,
-                                            TypeSourceInfo *TSI,
-                                            SourceRange Range, bool DirectInit,
-                                            Expr *Init) {
+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 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,
+    // FIXME: return TypeLoc.
+    auto T = DeduceTemplateSpecializationFromInitializer(TSI, Entity, Kind,
                                                          InitsCopy);
+    return T.isNull() ? nullptr : Context.getTrivialTypeSourceInfo(T);
   }
 
   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 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 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 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 {};
     }
     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());
+      DeduceInit->getType()->isConstantArrayType()) {
+    // FIXME: update the type loc.
+    return Context.getTrivialTypeSourceInfo(
+        Context.getQualifiedType(DeduceInit->getType(), Type.getQualifiers()));
+  }
 
-  QualType DeducedType;
-  if (DeduceAutoType(TSI, DeduceInit, DeducedType) == DAR_Failed) {
+  TypeSourceInfo *DeducedTSI;
+  if (DeduceAutoType(TSI, DeduceInit, DeducedTSI) == 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()) {
+      DeducedTSI && DeducedTSI->getType()->isObjCIdType()) {
     SourceLocation Loc = TSI->getTypeLoc().getBeginLoc();
     Diag(Loc, diag::warn_auto_var_is_id) << VN << Range;
   }
 
-  return DeducedType;
+  return DeducedTSI;
 }
 
 bool Sema::DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit,
                                          Expr *Init) {
-  QualType DeducedType = deduceVarTypeFromInitializer(
+  auto DeducedTSI = deduceVarTypeFromInitializer(
       VDecl, VDecl->getDeclName(), VDecl->getType(), VDecl->getTypeSourceInfo(),
       VDecl->getSourceRange(), DirectInit, Init);
-  if (DeducedType.isNull()) {
+  if (!DeducedTSI) {
     VDecl->setInvalidDecl();
     return true;
   }
 
-  VDecl->setType(DeducedType);
+  VDecl->setType(DeducedTSI->getType());
+  if (DeducedTSI->getTypeLoc())
+    VDecl->setTypeSourceInfo(DeducedTSI);
   assert(VDecl->isLinkageValid());
 
   // In ARC, infer lifetime.
   if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(VDecl))
     VDecl->setInvalidDecl();
 
   if (getLangOpts().OpenCL)
     deduceOpenCLAddressSpace(VDecl);

clang/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 *DeducedTSI;
+    if (DeduceAutoType(AllocTypeInfo, Deduce, DeducedTSI) == DAR_Failed)
       return ExprError(Diag(StartLoc, diag::err_auto_new_deduction_failure)
                        << AllocType << Deduce->getType()
                        << TypeRange << Deduce->getSourceRange());
-    if (DeducedType.isNull())
+    if (DeducedTSI == nullptr)
       return ExprError();
-    AllocType = DeducedType;
+    AllocType = DeducedTSI->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(),

clang/lib/Sema/SemaLambda.cpp

if (EllipsisLoc.isValid()) {
     } else {
       // Just ignore the ellipsis for now and form a non-pack variable. We'll
       // diagnose this later when we try to capture it.
     }
   }
   TypeSourceInfo *TSI = TLB.getTypeSourceInfo(Context, DeductType);
 
   // Deduce the type of the init capture.
-  QualType DeducedType = deduceVarTypeFromInitializer(
-      /*VarDecl*/nullptr, DeclarationName(Id), DeductType, TSI,
+  auto DeducedTSI = deduceVarTypeFromInitializer(
+      /*VarDecl*/ nullptr, DeclarationName(Id), DeductType, TSI,
       SourceRange(Loc, Loc), IsDirectInit, Init);
-  if (DeducedType.isNull())
+  if (!DeducedTSI)
     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.
-  InitializedEntity Entity =
-      InitializedEntity::InitializeLambdaCapture(Id, DeducedType, Loc);
+  InitializedEntity Entity = InitializedEntity::InitializeLambdaCapture(
+      Id, DeducedTSI->getType(), Loc);
   InitializationKind Kind =
       IsDirectInit
           ? (CXXDirectInit ? InitializationKind::CreateDirect(
                                  Loc, Init->getBeginLoc(), Init->getEndLoc())
                            : InitializationKind::CreateDirectList(Loc))
           : InitializationKind::CreateCopy(Loc, Init->getBeginLoc());
 
   MultiExprArg Args = Init;
   if (CXXDirectInit)
     Args =
         MultiExprArg(CXXDirectInit->getExprs(), CXXDirectInit->getNumExprs());
   QualType DclT;
   InitializationSequence InitSeq(*this, Entity, Kind, Args);
   ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT);
 
   if (Result.isInvalid())
     return QualType();
 
   Init = Result.getAs<Expr>();
-  return DeducedType;
+  return DeducedTSI->getType();
 }
 
 VarDecl *Sema::createLambdaInitCaptureVarDecl(SourceLocation Loc,
                                               QualType InitCaptureType,
                                               SourceLocation EllipsisLoc,
                                               IdentifierInfo *Id,
                                               unsigned InitStyle, Expr *Init) {
   // FIXME: Retain the TypeSourceInfo from buildLambdaInitCaptureInitialization

clang/lib/Sema/SemaStmt.cpp

 //===--- SemaStmt.cpp - Semantic Analysis for Statements ------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements semantic analysis for statements.
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/Sema/Ownership.h"
-#include "clang/Sema/SemaInternal.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/ASTLambda.h"
-#include "clang/AST/CharUnits.h"
 #include "clang/AST/CXXInheritance.h"
+#include "clang/AST/CharUnits.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/EvaluatedExprVisitor.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/AST/StmtObjC.h"
+#include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/AST/TypeOrdering.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
+#include "clang/Sema/Ownership.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
+#include "clang/Sema/SemaInternal.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 
 using namespace clang;
if (DeclStmt *DS = dyn_cast<DeclStmt>(First)) {
         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()) {
         OpaqueValueExpr OpaqueId(D->getLocation(), Context.getObjCIdType(),
                                  VK_RValue);
         Expr *DeducedInit = &OpaqueId;
-        if (DeduceAutoType(D->getTypeSourceInfo(), DeducedInit, FirstType) ==
-                DAR_Failed)
+        TypeSourceInfo *DeducedType;
+        if (DeduceAutoType(D->getTypeSourceInfo(), DeducedInit, DeducedType) ==
           DiagnoseAutoDeductionFailure(D, DeducedInit);
-        if (FirstType.isNull()) {
+        if (!DeducedType) {
           D->setInvalidDecl();
           return StmtError();
         }
+        // FIXME: do not drop source information.
+        FirstType = DeducedType->getType();
 
         D->setType(FirstType);
 
         if (!inTemplateInstantiation()) {
           SourceLocation Loc =
               D->getTypeSourceInfo()->getTypeLoc().getBeginLoc();
           Diag(Loc, diag::warn_auto_var_is_id)
             << D->getDeclName();
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 *InitType = nullptr;
   if ((!isa<InitListExpr>(Init) && Init->getType()->isVoidType()) ||
       SemaRef.DeduceAutoType(Decl->getTypeSourceInfo(), Init, InitType) ==
           Sema::DAR_Failed)
     SemaRef.Diag(Loc, DiagID) << Init->getType();
-  if (InitType.isNull()) {
+  if (!InitType) {
     Decl->setInvalidDecl();
     return true;
   }
-  Decl->setType(InitType);
+  // FIXME: set TypeLoc.
+  Decl->setType(InitType->getType());
 
   // 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;
+    // FIXME: is there a way to avoid creating TSI?
+    auto *InputTSI = Context.CreateTypeSourceInfo(
+        OrigResultType.getType(), OrigResultType.getFullDataSize());
+    InputTSI->getTypeLoc().initializeFullCopy(OrigResultType);
 
+    DeduceAutoResult DAR = DeduceAutoType(InputTSI, 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;
 
+    Deduced = DeducedTSI->getType();
+
     // If a local type is part of the returned type, mark its fields as
     // referenced.
     LocalTypedefNameReferencer Referencer(*this);
     Referencer.TraverseType(RetExpr->getType());
   } else {
     //  In the case of a return with no operand, the initializer is considered
     //  to be void().
     //

clang/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 = Param->getDepth() + 1;
     Expr *DeductionArg = Arg;
     if (auto *PE = dyn_cast<PackExpansionExpr>(DeductionArg))
       DeductionArg = PE->getPattern();
+    TypeSourceInfo *DeducedParamTSI;
     if (DeduceAutoType(
             Context.getTrivialTypeSourceInfo(ParamType, Param->getLocation()),
-            DeductionArg, ParamType, Depth) == DAR_Failed) {
+            DeductionArg, DeducedParamTSI, 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(DeducedParamTSI->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() &&

clang/lib/Sema/SemaTemplateDeduction.cpp

QualType TransformDeducedTemplateSpecializationType(
       NewTL.setNameLoc(TL.getNameLoc());
       return Result;
     }
 
     ExprResult TransformLambdaExpr(LambdaExpr *E) {
       // Lambdas never need to be transformed.
       return E;
     }
-
-    QualType 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);
-    }
   };
 
 } // namespace
 
-Sema::DeduceAutoResult
-Sema::DeduceAutoType(TypeSourceInfo *Type, Expr *&Init, QualType &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.
 static bool diagnoseAutoDeductionFailure(Sema &S,
                                          Sema::TemplateDeductionResult TDK,
                                          TemplateDeductionInfo &Info,
                                          ArrayRef<SourceRange> Ranges) {
   switch (TDK) {

 /// \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(TypeSourceInfo *AutoTSI, Expr *&Init,
+                     TypeSourceInfo *&Result,
                      Optional<unsigned> DependentDeductionDepth) {
+  Result = nullptr;
+
+  TypeLoc Type = AutoTSI->getTypeLoc();
   if (Init->getType()->isNonOverloadPlaceholderType()) {
     ExprResult NonPlaceholder = CheckPlaceholderExpr(Init);
     if (NonPlaceholder.isInvalid())
       return DAR_FailedAlreadyDiagnosed;
     Init = NonPlaceholder.get();
   }
 
   DependentAuto DependentResult = {
       /*.IsPack = */ (bool)Type.getAs<PackExpansionTypeLoc>()};
 
   if (!DependentDeductionDepth &&
       (Type.getType()->isDependentType() || Init->isTypeDependent() ||
        Init->containsUnexpandedParameterPack())) {
-    Result = SubstituteDeducedTypeTransform(*this, DependentResult).Apply(Type);
-    assert(!Result.isNull() && "substituting DependentTy can't fail");
+    Result = SubstituteDeducedTypeTransform(*this, DependentResult)
+                 .TransformType(AutoTSI);
+    assert(Result && "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
if (AT->isDecltypeAuto()) {
       if (ER.isInvalid())
         return DAR_FailedAlreadyDiagnosed;
       Init = ER.get();
       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())
+      Result =
+          SubstituteDeducedTypeTransform(*this, Deduced).TransformType(AutoTSI);
+      if (!Result)
         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)
-          .Apply(Type);
-  assert(!FuncParam.isNull() &&
+  auto *FuncParamTSI =
+      SubstituteDeducedTypeTransform(*this, TemplArg, /*UseTypeSugar*/ false)
+          .TransformType(AutoTSI);
+  assert(FuncParamTSI != nullptr &&
          "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, DependentResult).Apply(Type);
-      assert(!Result.isNull() && "substituting DependentTy can't fail");
+      Result = SubstituteDeducedTypeTransform(*this, DependentResult)
+                   .TransformType(AutoTSI);
+      assert(Result != nullptr && "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())
+  Result =
+      SubstituteDeducedTypeTransform(*this, DeducedType).TransformType(AutoTSI);
+  if (Result == nullptr)
     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,