Lines Matching refs:Loc
774 for (auto Loc : BadSpecifierLocs)
775 Err << SourceRange(Loc, Loc);
784 for (auto Loc : CPlusPlus20SpecifierLocs)
785 Warn << SourceRange(Loc, Loc);
900 SourceLocation Loc = B->getLocation();
901 ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
904 E = GetInit(Loc, E.get(), I++);
920 [&](SourceLocation Loc, Expr *Base, unsigned I) -> ExprResult {
921 ExprResult E = S.ActOnIntegerConstant(Loc, I);
924 return S.CreateBuiltinArraySubscriptExpr(Base, Loc, E.get(), Loc);
953 [&](SourceLocation Loc, Expr *Base, unsigned I) -> ExprResult {
954 return S.CreateBuiltinUnaryOp(Loc, I ? UO_Imag : UO_Real, Base);
973 SourceLocation Loc, StringRef Trait,
978 S.Diag(Loc, DiagID) << printTemplateArgs(S.Context.getPrintingPolicy(),
994 Loc, Sema::LookupOrdinaryName);
1004 S.Diag(Loc, diag::err_std_type_trait_not_class_template) << Trait;
1010 QualType TraitTy = S.CheckTemplateIdType(TemplateName(TraitTD), Loc, Args);
1013 if (!S.isCompleteType(Loc, TraitTy)) {
1016 Loc, TraitTy, DiagID,
1030 getTrivialIntegralTemplateArgument(Sema &S, SourceLocation Loc, QualType T,
1033 return S.getTrivialTemplateArgumentLoc(Arg, T, Loc);
1037 getTrivialTypeTemplateArgument(Sema &S, SourceLocation Loc, QualType T) {
1038 return S.getTrivialTemplateArgumentLoc(TemplateArgument(T), QualType(), Loc);
1043 static IsTupleLike isTupleLike(Sema &S, SourceLocation Loc, QualType T,
1049 LookupResult R(S, Value, Loc, Sema::LookupOrdinaryName);
1052 TemplateArgumentListInfo Args(Loc, Loc);
1053 Args.addArgument(getTrivialTypeTemplateArgument(S, Loc, T));
1057 if (lookupStdTypeTraitMember(S, R, Loc, "tuple_size", Args, /*DiagID*/ 0) ||
1069 void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) override {
1070 S.Diag(Loc, diag::err_decomp_decl_std_tuple_size_not_constant)
1088 static QualType getTupleLikeElementType(Sema &S, SourceLocation Loc,
1091 TemplateArgumentListInfo Args(Loc, Loc);
1093 getTrivialIntegralTemplateArgument(S, Loc, S.Context.getSizeType(), I));
1094 Args.addArgument(getTrivialTypeTemplateArgument(S, Loc, T));
1097 LookupResult R(S, TypeDN, Loc, Sema::LookupOrdinaryName);
1099 S, R, Loc, "tuple_element", Args,
1106 S.Diag(Loc, diag::err_decomp_decl_std_tuple_element_not_specialized)
1177 SourceLocation Loc = B->getLocation();
1179 ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
1189 TemplateArgumentListInfo Args(Loc, Loc);
1191 getTrivialIntegralTemplateArgument(S, Loc, S.Context.getSizeType(), I));
1196 E = S.BuildMemberReferenceExpr(E.get(), DecompType, Loc, false,
1202 E = S.BuildCallExpr(nullptr, E.get(), Loc, None, Loc);
1208 DeclarationNameInfo(GetDN, Loc), /*RequiresADL*/true, &Args,
1212 E = S.BuildCallExpr(nullptr, Get, Loc, Arg, Loc);
1219 QualType T = getTupleLikeElementType(S, Loc, I, DecompType);
1227 S.BuildReferenceType(T, E.get()->isLValue(), Loc, B->getDeclName());
1231 S.Context, Src->getDeclContext(), Loc, Loc,
1233 S.Context.getTrivialTypeSourceInfo(T, Loc), Src->getStorageClass());
1242 InitializationKind Kind = InitializationKind::CreateCopy(Loc, Loc);
1247 E = S.ActOnFinishFullExpr(E.get(), Loc, /*DiscardedValue*/ false);
1255 DeclarationNameInfo(B->getDeclName(), Loc),
1270 static DeclAccessPair findDecomposableBaseClass(Sema &S, SourceLocation Loc,
1302 S.Diag(Loc, diag::err_decomp_decl_multiple_bases_with_members)
1314 S.Diag(Loc, diag::err_decomp_decl_ambiguous_base)
1320 S.CheckBaseClassAccess(Loc, BaseType, S.Context.getRecordType(RD),
1332 S.Diag(Loc, diag::err_decomp_decl_multiple_bases_with_members)
1387 SourceLocation Loc = B->getLocation();
1394 Loc, const_cast<CXXRecordDecl *>(OrigRD),
1399 ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
1406 E = S.BuildFieldReferenceExpr(E.get(), /*IsArrow*/ false, Loc,
1409 DeclarationNameInfo(FD->getDeclName(), Loc));
1421 B->setBinding(S.BuildQualifiedType(FD->getType(), Loc, Q), E.get());
1592 SourceLocation Loc, QualType T, unsigned DiagID,
1599 return SemaRef.RequireLiteralType(Loc, T, DiagID,
1613 auto Check = [&](SourceLocation Loc, QualType T, const FieldDecl *FD) {
1623 SemaRef.Diag(Loc, diag::note_constexpr_dtor_subobject)
2756 bool Sema::IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base) {
2775 if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined())
2783 bool Sema::IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base,
2796 if (!isCompleteType(Loc, Derived) && !DerivedRD->isBeingDefined())
2832 /// otherwise. Loc is the location where this routine should point to
2843 SourceLocation Loc, SourceRange Range,
2853 bool DerivationOkay = IsDerivedFrom(Loc, Derived, Base, Paths);
2869 Diag(Loc, diag::ext_ms_ambiguous_direct_base)
2880 CheckBaseClassAccess(Loc, Base, Derived, *Path, InaccessibleBaseID)) {
2905 bool StillOkay = IsDerivedFrom(Loc, Derived, Base, Paths);
2915 Diag(Loc, AmbiguousBaseConvID)
2923 SourceLocation Loc, SourceRange Range,
2928 diag::err_ambiguous_derived_to_base_conv, Loc, Range, DeclarationName(),
3055 SourceLocation Loc = MD->getLocation();
3056 SourceLocation SpellingLoc = Loc;
3057 if (getSourceManager().isMacroArgExpansion(Loc))
3058 SpellingLoc = getSourceManager().getImmediateExpansionRange(Loc).getBegin();
3120 void Sema::CheckShadowInheritedFields(const SourceLocation &Loc,
3124 if (Diags.isIgnored(diag::warn_shadow_field, Loc))
3162 Diag(Loc, diag::warn_shadow_field)
3183 SourceLocation Loc = NameInfo.getLoc();
3186 if (Loc.isInvalid())
3187 Loc = D.getBeginLoc();
3236 Diag(Loc, diag::err_invalid_member_in_interface)
3239 Diag(Loc, diag::err_invalid_member_in_interface)
3316 Diag(Loc, diag::err_bad_variable_name)
3363 Member = HandleMSProperty(S, cast<CXXRecordDecl>(CurContext), Loc, D,
3369 Member = HandleField(S, cast<CXXRecordDecl>(CurContext), Loc, D,
3375 CheckShadowInheritedFields(Loc, Name, cast<CXXRecordDecl>(CurContext));
3388 Diag(Loc, diag::err_static_not_bitfield)
3392 Diag(Loc, diag::err_typedef_not_bitfield)
3397 Diag(Loc, diag::err_not_integral_type_bitfield)
4645 SourceLocation Loc = Constructor->getLocation();
4659 Loc, ParamType, VK_LValue, nullptr);
4669 LookupResult MemberLookup(SemaRef, Field->getDeclName(), Loc,
4676 ParamType, Loc,
4702 InitializationKind::CreateDirect(Loc, SourceLocation(), SourceLocation());
4714 SemaRef.Context, Indirect, Loc, Loc, MemberInit.getAs<Expr>(), Loc);
4717 SemaRef.Context, Field, Loc, Loc, MemberInit.getAs<Expr>(), Loc);
4734 InitializationKind::CreateDefault(Loc);
4746 Indirect, Loc,
4747 Loc,
4749 Loc);
4752 Field, Loc, Loc,
4754 Loc);
4785 Loc, Loc,
4787 Loc);
5565 bool Sema::isAbstractType(SourceLocation Loc, QualType T) {
5586 bool Sema::RequireNonAbstractType(SourceLocation Loc, QualType T,
5588 if (!isAbstractType(Loc, T))
5592 Diagnoser.diagnose(*this, Loc, T);
7091 ComputingExceptionSpec(Sema &S, FunctionDecl *FD, SourceLocation Loc)
7095 Ctx.PointOfInstantiation = Loc;
7107 Sema &S, SourceLocation Loc, CXXMethodDecl *MD, Sema::CXXSpecialMember CSM,
7111 ComputeDefaultedComparisonExceptionSpec(Sema &S, SourceLocation Loc,
7116 computeImplicitExceptionSpec(Sema &S, SourceLocation Loc, FunctionDecl *FD) {
7120 S, Loc, cast<CXXMethodDecl>(FD), DFK.asSpecialMember(), nullptr);
7122 return ComputeDefaultedComparisonExceptionSpec(S, Loc, FD,
7130 S, Loc, CD->getInheritedConstructor().getShadowDecl());
7132 S, Loc, CD, Sema::CXXDefaultConstructor, &ICI);
7150 void Sema::EvaluateImplicitExceptionSpec(SourceLocation Loc, FunctionDecl *FD) {
7156 auto IES = computeImplicitExceptionSpec(*this, Loc, FD);
7528 SourceLocation Loc;
7593 S.Diag(Subobj.Loc, diag::note_defaulted_comparison_reference_member)
7669 ArgClass, Best->FoundDecl, ObjectType, Subobj.Loc,
7686 S.Diag(Subobj.Loc, diag::note_defaulted_comparison_not_constexpr)
7714 Subobj.Loc,
7728 S.Diag(Subobj.Loc, diag::note_defaulted_comparison_cannot_deduce)
7757 Subobj.Loc, S.PDiag(diag::note_defaulted_comparison_ambiguous)
7773 S.Diag(Subobj.Loc,
7796 S.Diag(Subobj.Loc, diag::note_defaulted_comparison_no_viable_function)
7806 S.Diag(Subobj.Loc,
7844 SourceLocation Loc;
7856 : Base(S, RD, FD, DCK), Loc(BodyLoc) {}
7909 CmpSoFar = S.CreateBuiltinBinOp(Loc, BO_LAnd, E, CmpSoFar.get());
7918 RetVal = S.ActOnCXXBoolLiteral(Loc, tok::kw_true);
7926 ComparisonCategoryType::StrongOrdering, Loc,
7949 StmtResult ReturnStmt = S.BuildReturnStmt(Loc, RetVal.get());
7954 return S.ActOnCompoundStmt(Loc, Loc, Stmts.Stmts, /*IsStmtExpr=*/false);
7960 CXXScopeSpec(), DeclarationNameInfo(VD->getDeclName(), Loc), VD);
7973 LHS = S.ActOnCXXThis(Loc);
7975 LHS = S.CreateBuiltinUnaryOp(Loc, UO_Deref, LHS.get());
8001 DeclarationNameInfo NameInfo(Field->getDeclName(), Loc);
8002 return {S.BuildFieldReferenceExpr(Obj.first.get(), /*IsArrow=*/false, Loc,
8004 S.BuildFieldReferenceExpr(Obj.second.get(), /*IsArrow=*/false, Loc,
8015 ExprResult NotCond = S.CreateBuiltinUnaryOp(Loc, UO_LNot, Cond.get());
8019 ExprResult False = S.ActOnCXXBoolLiteral(Loc, tok::kw_false);
8021 StmtResult ReturnFalse = S.BuildReturnStmt(Loc, False.get());
8025 return S.ActOnIfStmt(Loc, false, nullptr,
8026 S.ActOnCondition(nullptr, Loc, NotCond.get(),
8045 S.Context, S.CurContext, Loc, Loc, IterationVarName, SizeType,
8046 S.Context.getTrivialTypeSourceInfo(SizeType, Loc), SC_None);
8049 IntegerLiteral::Create(S.Context, Zero, SizeType, Loc));
8050 Stmt *Init = new (S.Context) DeclStmt(DeclGroupRef(IterationVar), Loc, Loc);
8054 CXXScopeSpec(), DeclarationNameInfo(IterationVarName, Loc),
8062 Loc, BO_NE, IterRef(),
8063 IntegerLiteral::Create(S.Context, Size, SizeType, Loc));
8067 ExprResult Inc = S.CreateBuiltinUnaryOp(Loc, UO_PreInc, IterRef());
8074 return S.CreateBuiltinArraySubscriptExpr(E.get(), Loc, IterRef(), Loc);
8099 return S.ActOnForStmt(Loc, Loc, Init,
8100 S.ActOnCondition(nullptr, Loc, Cond.get(),
8102 S.MakeFullDiscardedValueExpr(Inc.get()), Loc,
8114 Op = S.CreateOverloadedBinOp(Loc, Opc, Fns, Obj.first.get(),
8118 Op = S.CreateBuiltinBinOp(Loc, Opc, Obj.first.get(), Obj.second.get());
8146 VarDecl::Create(S.Context, S.CurContext, Loc, Loc, Name, R,
8147 S.Context.getTrivialTypeSourceInfo(R, Loc), SC_None);
8149 Stmt *InitStmt = new (S.Context) DeclStmt(DeclGroupRef(VD), Loc, Loc);
8157 IntegerLiteral::Create(S.Context, ZeroVal, S.Context.IntTy, Loc);
8160 Comp = S.CreateOverloadedBinOp(Loc, BO_NE, Fns, VDRef.get(), Zero, true,
8163 Comp = S.CreateBuiltinBinOp(Loc, BO_NE, VDRef.get(), Zero);
8167 nullptr, Loc, Comp.get(), Sema::ConditionKind::Boolean);
8175 StmtResult ReturnStmt = S.BuildReturnStmt(Loc, VDRef.get());
8180 return S.ActOnIfStmt(Loc, /*IsConstexpr=*/false, InitStmt, Cond,
8202 return S.BuildCXXNamedCast(Loc, tok::kw_static_cast,
8203 S.Context.getTrivialTypeSourceInfo(R, Loc), E,
8204 SourceRange(Loc, Loc), SourceRange(Loc, Loc));
8298 if (FunctionTypeLoc Loc = MD->getFunctionTypeLoc())
8299 InsertLoc = getLocForEndOfToken(Loc.getRParenLoc());
8496 ComputeDefaultedComparisonExceptionSpec(Sema &S, SourceLocation Loc,
8499 ComputingExceptionSpec CES(S, FD, Loc);
8680 SourceLocation Loc;
8688 Loc(MD->getLocation()), AllFieldsAreConst(true) {}
10225 SourceLocation Loc;
10228 Loc = Destructor->getLocation();
10230 Loc = RD->getLocation();
10234 FindDeallocationFunctionForDestructor(Loc, RD)) {
10254 Diag(Loc, diag::note_implicit_delete_this_in_destructor_here);
10261 DiagnoseUseOfDecl(OperatorDelete, Loc);
10262 MarkFunctionReferenced(Loc, OperatorDelete);
10491 extendLeft(Before, Chunk.Loc);
10497 SourceLocation Loc = Before.isValid() ? Before.getBegin() :
10500 auto &&DB = Diag(Loc, diag::err_conv_function_with_complex_decl);
10610 BadSpecifierDiagnoser(Sema &S, SourceLocation Loc, unsigned DiagID)
10611 : S(S), Diagnostic(S.Diag(Loc, DiagID)) {}
10759 SourceLocation Loc,
10771 S.getSourceManager().isInSystemHeader(Loc)) {
10787 S.Diag(Loc, diag::warn_inline_namespace_reopened_noninline)
10790 S.Diag(Loc, diag::err_inline_namespace_mismatch);
10804 SourceLocation Loc = II ? IdentLoc : LBrace;
10834 DiagnoseNamespaceInlineMismatch(*this, NamespaceLoc, Loc, II,
10838 Diag(Loc, diag::err_redefinition_different_kind)
10872 StartLoc, Loc, II, PrevNS);
10881 PushNamespaceVisibilityAttr(Attr, Loc);
11002 SourceLocation Loc;
11008 auto D = S.Diag(Loc, diag::err_std_compare_type_not_supported)
11025 SourceLocation Loc,
11044 if (RequireCompleteType(Loc, TyForDiags(Info), diag::err_incomplete_type))
11054 Diag(Loc, diag::err_implied_comparison_category_type_not_found)
11067 if (RequireCompleteType(Loc, TyForDiags(Info), diag::err_incomplete_type))
11070 InvalidSTLDiagnoser UnsupportedSTLError{*this, Loc, TyForDiags(Info)};
11119 MarkVariableReferenced(Loc, VD);
11205 static ClassTemplateDecl *LookupStdInitializerList(Sema &S, SourceLocation Loc){
11208 S.Diag(Loc, diag::err_implied_std_initializer_list_not_found);
11213 Loc, Sema::LookupOrdinaryName);
11215 S.Diag(Loc, diag::err_implied_std_initializer_list_not_found);
11239 QualType Sema::BuildStdInitializerList(QualType Element, SourceLocation Loc) {
11241 StdInitializerList = LookupStdInitializerList(*this, Loc);
11246 TemplateArgumentListInfo Args(Loc, Loc);
11249 Loc)));
11251 CheckTemplateIdType(TemplateName(StdInitializerList), Loc, Args));
12695 SourceLocation Loc;
12701 SourceLocation Loc)
12702 : SpecialMemberVisitor(S, MD, CSM, ICI), Loc(Loc), ExceptSpec(S) {}
12737 // FIXME: We should have a single context note pointing at Loc, and
12740 E = S.BuildCXXDefaultInitExpr(Loc, FD).get();
12791 Sema &S, SourceLocation Loc, CXXMethodDecl *MD, Sema::CXXSpecialMember CSM,
12793 ComputingExceptionSpec CES(S, MD, Loc);
13000 SourceLocation Loc = Constructor->getEndLoc().isValid()
13003 Constructor->setBody(new (Context) CompoundStmt(Loc));
13021 Sema::findInheritingConstructor(SourceLocation Loc,
13049 InheritedConstructorInfo ICI(*this, Loc, Shadow);
13288 SourceLocation Loc = Destructor->getEndLoc().isValid()
13291 Destructor->setBody(new (Context) CompoundStmt(Loc));
13410 virtual Expr *build(Sema &S, SourceLocation Loc) const = 0;
13418 Expr *build(Sema &S, SourceLocation Loc) const override {
13419 return assertNotNull(S.BuildDeclRefExpr(Var, VarType, VK_LValue, Loc));
13428 Expr *build(Sema &S, SourceLocation Loc) const override {
13429 return assertNotNull(S.ActOnCXXThis(Loc).getAs<Expr>());
13440 Expr *build(Sema &S, SourceLocation Loc) const override {
13441 return assertNotNull(S.ImpCastExprToType(Builder.build(S, Loc), Type,
13455 Expr *build(Sema &S, SourceLocation Loc) const override {
13457 S.CreateBuiltinUnaryOp(Loc, UO_Deref, Builder.build(S, Loc)).get());
13471 Expr *build(Sema &S, SourceLocation Loc) const override {
13473 Builder.build(S, Loc), Type, Loc, IsArrow, SS, SourceLocation(),
13487 Expr *build(Sema &S, SourceLocation Loc) const override {
13488 return assertNotNull(CastForMoving(S, Builder.build(S, Loc)));
13498 Expr *build(Sema &S, SourceLocation Loc) const override {
13500 S.DefaultLvalueConversion(Builder.build(S, Loc)).get());
13511 Expr *build(Sema &S, SourceLocation Loc) const override {
13513 Base.build(S, Loc), Loc, Index.build(S, Loc), Loc).get());
13527 buildMemcpyForAssignmentOp(Sema &S, SourceLocation Loc, QualType T,
13537 Expr *From = FromB.build(S, Loc);
13540 VK_RValue, OK_Ordinary, Loc, false, S.CurFPFeatureOverrides());
13541 Expr *To = ToB.build(S, Loc);
13544 VK_RValue, OK_Ordinary, Loc, false, S.CurFPFeatureOverrides());
13555 LookupResult R(S, &S.Context.Idents.get(MemCpyName), Loc,
13566 VK_RValue, Loc, nullptr);
13570 To, From, IntegerLiteral::Create(S.Context, Size, SizeType, Loc)
13573 Loc, CallArgs, Loc);
13588 /// \param Loc The location where the implicit copy/move is being generated.
13607 buildSingleCopyAssignRecursively(Sema &S, SourceLocation Loc, QualType T,
13631 LookupResult OpLookup(S, Name, Loc, Sema::LookupOrdinaryName);
13677 Loc);
13681 = S.BuildMemberReferenceExpr(To.build(S, Loc), T, Loc, /*IsArrow=*/false,
13692 Expr *FromInst = From.build(S, Loc);
13695 Loc, FromInst, Loc);
13715 Loc, BO_Assign, To.build(S, Loc), From.build(S, Loc));
13739 VarDecl *IterationVar = VarDecl::Create(S.Context, S.CurContext, Loc, Loc,
13741 S.Context.getTrivialTypeSourceInfo(SizeType, Loc),
13746 IterationVar->setInit(IntegerLiteral::Create(S.Context, Zero, SizeType, Loc));
13753 Stmt *InitStmt = new (S.Context) DeclStmt(DeclGroupRef(IterationVar),Loc,Loc);
13768 buildSingleCopyAssignRecursively(S, Loc, ArrayTy->getElementType(),
13779 S.Context, IterationVarRefRVal.build(S, Loc),
13780 IntegerLiteral::Create(S.Context, Upper, SizeType, Loc), BO_NE,
13781 S.Context.BoolTy, VK_RValue, OK_Ordinary, Loc, S.CurFPFeatureOverrides());
13787 S.Context, IterationVarRef.build(S, Loc), UO_PreInc, SizeType, VK_LValue,
13788 OK_Ordinary, Loc, Upper.isMaxValue(), S.CurFPFeatureOverrides());
13792 Loc, Loc, InitStmt,
13793 S.ActOnCondition(nullptr, Loc, Comparison, Sema::ConditionKind::Boolean),
13794 S.MakeFullDiscardedValueExpr(Increment), Loc, Copy.get());
13798 buildSingleCopyAssign(Sema &S, SourceLocation Loc, QualType T,
13804 return buildMemcpyForAssignmentOp(S, Loc, T, To, From);
13806 StmtResult Result(buildSingleCopyAssignRecursively(S, Loc, T, To, From,
13813 return buildMemcpyForAssignmentOp(S, Loc, T, To, From);
14000 SourceLocation Loc = CopyAssignOperator->getEndLoc().isValid()
14037 StmtResult Copy = buildSingleCopyAssign(*this, Loc, BaseType,
14094 LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
14104 StmtResult Copy = buildSingleCopyAssign(*this, Loc, FieldType,
14119 ExprResult ThisObj = CreateBuiltinUnaryOp(Loc, UO_Deref, This.build(*this, Loc));
14121 StmtResult Return = BuildReturnStmt(Loc, ThisObj.get());
14136 Body = ActOnCompoundStmt(Loc, Loc, Statements,
14358 SourceLocation Loc = MoveAssignOperator->getEndLoc().isValid()
14406 StmtResult Move = buildSingleCopyAssign(*this, Loc, BaseType,
14462 LookupResult MemberLookup(*this, Field->getDeclName(), Loc,
14471 assert(!From.build(*this, Loc)->isLValue() && // could be xvalue or prvalue
14476 StmtResult Move = buildSingleCopyAssign(*this, Loc, FieldType,
14492 CreateBuiltinUnaryOp(Loc, UO_Deref, This.build(*this, Loc));
14494 StmtResult Return = BuildReturnStmt(Loc, ThisObj.get());
14509 Body = ActOnCompoundStmt(Loc, Loc, Statements,
14646 SourceLocation Loc = CopyConstructor->getEndLoc().isValid()
14651 ActOnCompoundStmt(Loc, Loc, None, /*isStmtExpr=*/false).getAs<Stmt>());
14772 SourceLocation Loc = MoveConstructor->getEndLoc().isValid()
14777 Loc, Loc, None, /*isStmtExpr=*/ false).getAs<Stmt>());
15015 ExprResult Sema::BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field) {
15020 return CXXDefaultInitExpr::Create(Context, Loc, Field, CurContext);
15055 InstantiateInClassInitializer(Loc, Field, Pattern,
15061 return CXXDefaultInitExpr::Create(Context, Loc, Field, CurContext);
15079 Diag(Loc, diag::err_in_class_initializer_not_yet_parsed)
15153 SourceLocation Loc,
15173 bool Invalid = GatherArgumentsForCall(Loc, Constructor,
15181 DiagnoseSentinelCalls(Constructor, Loc, AllArgs);
15185 Proto, Loc);
15773 SourceLocation Loc,
15789 Diag(Loc, diag::err_catch_rvalue_ref);
15794 Diag(Loc, diag::err_catch_variably_modified) << ExDeclType;
15812 !BaseType->isDependentType() && RequireCompleteType(Loc, BaseType, DK))
15816 Diag(Loc, diag::err_catch_sizeless) << (Mode == 2 ? 1 : 0) << BaseType;
15821 RequireNonAbstractType(Loc, ExDeclType,
15834 Diag(Loc, diag::err_objc_object_catch);
15839 Diag(Loc, diag::warn_objc_pointer_cxx_catch_fragile);
15843 VarDecl *ExDecl = VarDecl::Create(Context, CurContext, StartLoc, Loc, Name,
15871 InitializationKind::CreateCopy(Loc, SourceLocation());
15874 new (Context) OpaqueValueExpr(Loc, initType, VK_LValue, OK_Ordinary);
16254 SourceLocation Loc = DS.getBeginLoc();
16291 if (DiagnoseUnexpandedParameterPack(Loc, TSI, UPPC_FriendDeclaration))
16309 Diag(Loc, diag::err_tagless_friend_type_template)
16327 D = FriendTemplateDecl::Create(Context, CurContext, Loc,
16332 D = CheckFriendTypeDecl(Loc, DS.getFriendSpecLoc(), TSI);
16350 SourceLocation Loc = D.getIdentifierLoc();
16364 Diag(Loc, diag::err_unexpected_friend);
16391 if (DiagnoseUnexpandedParameterPack(Loc, TInfo, UPPC_FriendDeclaration) ||
16577 Diag(Loc, diag::err_introducing_special_friend) << DiagArg;
17099 void Sema::MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class,
17112 MarkVirtualMembersReferenced(Loc, Class);
17146 MarkFunctionReferenced(Loc, Class->getDestructor());
17156 MarkVirtualMembersReferenced(Loc, Class);
17158 VTableUses.push_back(std::make_pair(Class, Loc));
17178 SourceLocation Loc = VTableUses[I].second;
17221 MarkVirtualMemberExceptionSpecsNeeded(Loc, Class);
17229 MarkVirtualMembersReferenced(Loc, Class);
17255 void Sema::MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc,
17259 ResolveExceptionSpec(Loc, I->getType()->castAs<FunctionProtoType>());
17262 void Sema::MarkVirtualMembersReferenced(SourceLocation Loc,
17280 MarkFunctionReferenced(Loc, Overrider);
17293 MarkVirtualMembersReferenced(Loc, Base);
17671 SourceLocation Loc = D.getIdentifierLoc();
17682 TInfo = Context.getTrivialTypeSourceInfo(T, Loc);
17698 LookupResult Previous(*this, II, Loc, LookupMemberName,
17729 MSPropertyDecl::Create(Context, Record, Loc, II, T, TInfo, TSSL,