kadircet created this revision. kadircet added a reviewer: ilya-biryukov. Herald added a subscriber: cfe-commits.
Repository: rC Clang https://reviews.llvm.org/D52301 Files: include/clang/AST/PrettyPrinter.h include/clang/Basic/DiagnosticSemaKinds.td include/clang/Sema/Sema.h lib/AST/TypePrinter.cpp lib/Frontend/ASTConsumers.cpp lib/Sema/SemaChecking.cpp lib/Sema/SemaDecl.cpp lib/Sema/SemaExprCXX.cpp lib/Sema/SemaLambda.cpp lib/Sema/SemaStmt.cpp lib/Sema/SemaTemplate.cpp lib/Sema/SemaTemplateDeduction.cpp lib/Tooling/Refactoring/Rename/USRLocFinder.cpp test/Analysis/scopes-cfg-output.cpp test/Driver/Xarch.c test/SemaOpenCL/to_addr_builtin.cl
Index: test/SemaOpenCL/to_addr_builtin.cl =================================================================== --- test/SemaOpenCL/to_addr_builtin.cl +++ test/SemaOpenCL/to_addr_builtin.cl @@ -1,5 +1,5 @@ // RUN: %clang_cc1 -verify -fsyntax-only %s -// RUN: %clang_cc1 -Wconversion -verify -fsyntax-only -cl-std=CL2.0 %s +// RUN: %clang_cc1 -verify -fsyntax-only -cl-std=CL2.0 %s void test(void) { global int *glob; @@ -43,15 +43,13 @@ // expected-warning@-2{{incompatible integer to pointer conversion assigning to '__local int *' from 'int'}} #else // expected-error@-4{{assigning '__global int *' to '__local int *' changes address space of pointer}} - // expected-warning@-5{{passing non-generic address space pointer to to_global may cause dynamic conversion affecting performance}} #endif global char *glob_c = to_global(loc); #if __OPENCL_C_VERSION__ < CL_VERSION_2_0 // expected-warning@-2{{incompatible integer to pointer conversion initializing '__global char *' with an expression of type 'int'}} #else // expected-warning@-4{{incompatible pointer types initializing '__global char *' with an expression of type '__global int *'}} - // expected-warning@-5{{passing non-generic address space pointer to to_global may cause dynamic conversion affecting performance}} #endif } Index: test/Driver/Xarch.c =================================================================== --- test/Driver/Xarch.c +++ test/Driver/Xarch.c @@ -1,12 +1,9 @@ -// RUN: %clang -target i386-apple-darwin9 -m32 -Xarch_i386 -O2 %s -S -### 2>&1 | FileCheck -check-prefix=O2ONCE %s -// O2ONCE: "-O2" -// O2ONCE-NOT: "-O2" +// RUN: %clang -target i386-apple-darwin9 -m32 -Xarch_i386 -O2 %s -S -### 2> %t.log +// RUN: grep ' "-O2" ' %t.log | count 1 +// RUN: %clang -target i386-apple-darwin9 -m64 -Xarch_i386 -O2 %s -S -### 2> %t.log +// RUN: not grep ' "-O2" ' %t.log +// RUN: grep "argument unused during compilation: '-Xarch_i386 -O2'" %t.log +// RUN: not %clang -target i386-apple-darwin9 -m32 -Xarch_i386 -o -Xarch_i386 -S %s -S -Xarch_i386 -o 2> %t.log +// RUN: grep "error: invalid Xarch argument: '-Xarch_i386 -o'" %t.log | count 2 +// RUN: grep "error: invalid Xarch argument: '-Xarch_i386 -S'" %t.log -// RUN: %clang -target i386-apple-darwin9 -m64 -Xarch_i386 -O2 %s -S -### 2>&1 | FileCheck -check-prefix=O2NONE %s -// O2NONE-NOT: "-O2" -// O2NONE: argument unused during compilation: '-Xarch_i386 -O2' - -// RUN: not %clang -target i386-apple-darwin9 -m32 -Xarch_i386 -o -Xarch_i386 -S %s -S -Xarch_i386 -o 2>&1 | FileCheck -check-prefix=INVALID %s -// INVALID: error: invalid Xarch argument: '-Xarch_i386 -o' -// INVALID: error: invalid Xarch argument: '-Xarch_i386 -S' -// INVALID: error: invalid Xarch argument: '-Xarch_i386 -o' Index: test/Analysis/scopes-cfg-output.cpp =================================================================== --- test/Analysis/scopes-cfg-output.cpp +++ test/Analysis/scopes-cfg-output.cpp @@ -820,7 +820,7 @@ // CHECK-NEXT: 3: __end1 // CHECK-NEXT: 4: [B2.3] (ImplicitCastExpr, LValueToRValue, class A *) // CHECK-NEXT: 5: [B2.2] != [B2.4] -// CHECK-NEXT: T: for (auto &i : [B5.4]) { +// CHECK-NEXT: T: for (A &i : [B5.4]) { // CHECK: [B4.11]; // CHECK-NEXT:} // CHECK-NEXT: Preds (2): B3 B5 @@ -835,7 +835,7 @@ // CHECK-NEXT: 2: __begin1 // CHECK-NEXT: 3: [B4.2] (ImplicitCastExpr, LValueToRValue, class A *) // CHECK-NEXT: 4: *[B4.3] -// CHECK-NEXT: 5: auto &i = *__begin1; +// CHECK-NEXT: 5: A &i = *__begin1; // CHECK-NEXT: 6: operator= // CHECK-NEXT: 7: [B4.6] (ImplicitCastExpr, FunctionToPointerDecay, class A &(*)(const class A &) // CHECK-NEXT: 8: i @@ -850,16 +850,16 @@ // CHECK-NEXT: 2: (CXXConstructExpr, [B5.3], class A [10]) // CHECK-NEXT: 3: A a[10]; // CHECK-NEXT: 4: a -// CHECK-NEXT: 5: auto &&__range1 = a; +// CHECK-NEXT: 5: A (&__range1)[10] = a; // CHECK-NEXT: 6: CFGScopeBegin(__end1) // CHECK-NEXT: 7: __range1 // CHECK-NEXT: 8: [B5.7] (ImplicitCastExpr, ArrayToPointerDecay, class A *) // CHECK-NEXT: 9: 10 // CHECK-NEXT: 10: [B5.8] + [B5.9] -// CHECK-NEXT: 11: auto __end1 = __range1 + 10 +// CHECK-NEXT: 11: A *__end1 = __range1 + 10 // CHECK-NEXT: 12: __range1 // CHECK-NEXT: 13: [B5.12] (ImplicitCastExpr, ArrayToPointerDecay, class A *) -// CHECK-NEXT: 14: auto __begin1 = __range1; +// CHECK-NEXT: 14: A *__begin1 = __range1; // CHECK-NEXT: Preds (1): B6 // CHECK-NEXT: Succs (1): B2 // CHECK: [B0 (EXIT)] Index: lib/Tooling/Refactoring/Rename/USRLocFinder.cpp =================================================================== --- lib/Tooling/Refactoring/Rename/USRLocFinder.cpp +++ lib/Tooling/Refactoring/Rename/USRLocFinder.cpp @@ -351,6 +351,8 @@ } bool VisitTypeLoc(TypeLoc Loc) { + if(Loc.getTypeLocClass() == TypeLoc::Auto) + return true; auto Parents = Context.getParents(Loc); TypeLoc ParentTypeLoc; if (!Parents.empty()) { Index: lib/Sema/SemaTemplateDeduction.cpp =================================================================== --- lib/Sema/SemaTemplateDeduction.cpp +++ lib/Sema/SemaTemplateDeduction.cpp @@ -4340,19 +4340,20 @@ 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); @@ -4398,7 +4399,7 @@ /// '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); @@ -4410,7 +4411,8 @@ 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; } @@ -4433,7 +4435,7 @@ // 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) { @@ -4456,10 +4458,10 @@ 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) @@ -4474,7 +4476,8 @@ 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)) @@ -4514,8 +4517,9 @@ } 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, {}); } @@ -4532,18 +4536,18 @@ } 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, {}); } } Index: lib/Sema/SemaTemplate.cpp =================================================================== --- lib/Sema/SemaTemplate.cpp +++ lib/Sema/SemaTemplate.cpp @@ -6157,9 +6157,10 @@ 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() @@ -6171,7 +6172,8 @@ // 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(); Index: lib/Sema/SemaStmt.cpp =================================================================== --- lib/Sema/SemaStmt.cpp +++ lib/Sema/SemaStmt.cpp @@ -1883,7 +1883,7 @@ 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(), @@ -1893,28 +1893,28 @@ 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 = @@ -1931,16 +1931,17 @@ 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()) @@ -1969,16 +1970,17 @@ // 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 @@ -3384,7 +3386,8 @@ 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) @@ -3397,6 +3400,7 @@ // 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(). Index: lib/Sema/SemaLambda.cpp =================================================================== --- lib/Sema/SemaLambda.cpp +++ lib/Sema/SemaLambda.cpp @@ -747,7 +747,7 @@ // 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(); Index: lib/Sema/SemaExprCXX.cpp =================================================================== --- lib/Sema/SemaExprCXX.cpp +++ lib/Sema/SemaExprCXX.cpp @@ -1840,14 +1840,14 @@ 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 Index: lib/Sema/SemaDecl.cpp =================================================================== --- lib/Sema/SemaDecl.cpp +++ lib/Sema/SemaDecl.cpp @@ -10763,7 +10763,7 @@ }; } // 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, @@ -10788,7 +10788,7 @@ VDecl->isStaticDataMember()) { Diag(VDecl->getLocation(), diag::err_auto_var_requires_init) << VDecl->getDeclName() << Type; - return QualType(); + return {QualType(), nullptr}; } } @@ -10808,8 +10808,8 @@ 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) { @@ -10825,33 +10825,33 @@ ? 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; @@ -10863,11 +10863,11 @@ 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)) @@ -10891,25 +10891,29 @@ // 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. Index: lib/Sema/SemaChecking.cpp =================================================================== --- lib/Sema/SemaChecking.cpp +++ lib/Sema/SemaChecking.cpp @@ -849,13 +849,6 @@ return true; } - if (RT->getPointeeType().getAddressSpace() != LangAS::opencl_generic) { - S.Diag(Call->getArg(0)->getBeginLoc(), - diag::warn_opencl_generic_address_space_arg) - << Call->getDirectCallee()->getNameInfo().getAsString() - << Call->getArg(0)->getSourceRange(); - } - RT = RT->getPointeeType(); auto Qual = RT.getQualifiers(); switch (BuiltinID) { Index: lib/Frontend/ASTConsumers.cpp =================================================================== --- lib/Frontend/ASTConsumers.cpp +++ lib/Frontend/ASTConsumers.cpp @@ -89,6 +89,9 @@ 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); Index: lib/AST/TypePrinter.cpp =================================================================== --- lib/AST/TypePrinter.cpp +++ lib/AST/TypePrinter.cpp @@ -1010,7 +1010,7 @@ 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()) { @@ -1024,7 +1024,7 @@ 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); } Index: include/clang/Sema/Sema.h =================================================================== --- include/clang/Sema/Sema.h +++ include/clang/Sema/Sema.h @@ -7031,10 +7031,12 @@ }; 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, @@ -7049,10 +7051,10 @@ 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, + QualType Type, TypeSourceInfo *TSI, + SourceRange Range, bool DirectInit, Expr *Init); TypeLoc getReturnTypeLoc(FunctionDecl *FD) const; Index: include/clang/Basic/DiagnosticSemaKinds.td =================================================================== --- include/clang/Basic/DiagnosticSemaKinds.td +++ include/clang/Basic/DiagnosticSemaKinds.td @@ -8613,10 +8613,6 @@ "invalid prototype, variadic arguments are not allowed in OpenCL">; def err_opencl_requires_extension : Error< "use of %select{type|declaration}0 %1 requires %2 extension to be enabled">; -def warn_opencl_generic_address_space_arg : Warning< - "passing non-generic address space pointer to %0" - " may cause dynamic conversion affecting performance">, - InGroup<Conversion>, DefaultIgnore; // OpenCL v2.0 s6.13.6 -- Builtin Pipe Functions def err_opencl_builtin_pipe_first_arg : Error< Index: include/clang/AST/PrettyPrinter.h =================================================================== --- include/clang/AST/PrettyPrinter.h +++ include/clang/AST/PrettyPrinter.h @@ -52,7 +52,7 @@ 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 @@ -225,6 +225,11 @@ /// 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
_______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits