Lines Matching refs:Arg
90 TemplateArgument Arg,
122 QualType Arg,
406 TemplateName Arg,
418 DeducedTemplateArgument NewDeduced(S.Context.getCanonicalTemplateName(Arg));
434 if (S.Context.hasSameTemplateName(Param, Arg))
439 Info.SecondArg = TemplateArgument(Arg);
452 /// \param Arg the argument type
465 QualType Arg,
468 assert(Arg.isCanonical() && "Argument type must be canonical");
472 = dyn_cast<TemplateSpecializationType>(Arg)) {
494 const RecordType *RecordArg = dyn_cast<RecordType>(Arg);
497 Info.SecondArg = TemplateArgument(Arg);
505 Info.SecondArg = TemplateArgument(Arg);
881 /// \param Arg the argument type.
883 CanQualType Arg) {
885 *ArgFunction = Arg->getAs<FunctionType>();
889 return Param == Arg;
893 if (IsNoReturnConversion(Param, Arg, AdjustedParam))
894 return Arg == Context.getCanonicalType(AdjustedParam);
898 return Param == Arg;
941 QualType Arg = S.Context.getCanonicalType(ArgIn);
946 = dyn_cast<PackExpansionType>(Arg))
947 Arg = ArgExpansion->getPattern();
959 const ReferenceType *ArgRef = Arg->getAs<ReferenceType>();
961 Arg = ArgRef->getPointeeType();
979 Qualifiers ArgQuals = Arg.getQualifiers();
994 Arg = Arg.getUnqualifiedType();
1004 Arg.getCVRQualifiers());
1026 if (Arg->isLValueReferenceType())
1042 if (Arg->isPlaceholderType())
1050 if (isa<ArrayType>(Arg)) {
1052 Arg = S.Context.getUnqualifiedArrayType(Arg, Quals);
1054 Arg = S.Context.getQualifiedType(Arg, Quals);
1062 hasInconsistentOrSupersetQualifiersOf(Param, Arg)) {
1065 Info.SecondArg = TemplateArgument(Arg);
1070 assert(Arg != S.Context.OverloadTy && "Unresolved overloaded function");
1071 QualType DeducedType = Arg;
1092 Info.SecondArg = TemplateArgument(Arg);
1138 CanQualType CanArg = S.Context.getCanonicalType(Arg);
1141 if (hasInconsistentOrSupersetQualifiersOf(Param, Arg))
1144 if (Param.getCVRQualifiers() != Arg.getCVRQualifiers())
1153 Param != Arg;
1198 Arg = Arg.getUnqualifiedType();
1201 return Param == Arg? Sema::TDK_Success : Sema::TDK_NonDeducedMismatch;
1206 if (const ComplexType *ComplexArg = Arg->getAs<ComplexType>())
1216 if (const AtomicType *AtomicArg = Arg->getAs<AtomicType>())
1227 if (const PointerType *PointerArg = Arg->getAs<PointerType>()) {
1230 = Arg->getAs<ObjCObjectPointerType>()) {
1245 const LValueReferenceType *ReferenceArg = Arg->getAs<LValueReferenceType>();
1256 const RValueReferenceType *ReferenceArg = Arg->getAs<RValueReferenceType>();
1269 S.Context.getAsIncompleteArrayType(Arg);
1283 S.Context.getAsConstantArrayType(Arg);
1301 const ArrayType *ArrayArg = S.Context.getAsArrayType(Arg);
1352 dyn_cast<FunctionProtoType>(Arg);
1403 = DeduceTemplateArguments(S, TemplateParams, SpecParam, Arg,
1416 if (const RecordType *RecordT = Arg->getAs<RecordType>()) {
1420 if (S.RequireCompleteType(Info.getLocation(), Arg, 0))
1496 const MemberPointerType *MemPtrArg = dyn_cast<MemberPointerType>(Arg);
1522 const BlockPointerType *BlockPtrArg = dyn_cast<BlockPointerType>(Arg);
1538 if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) {
1551 = dyn_cast<DependentSizedExtVectorType>(Arg)) {
1573 if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) {
1595 = dyn_cast<DependentSizedExtVectorType>(Arg)) {
1637 TemplateArgument Arg,
1643 if (Arg.isPackExpansion())
1644 Arg = Arg.getPackExpansionPattern();
1651 if (Arg.getKind() == TemplateArgument::Type)
1654 Arg.getAsType(),
1657 Info.SecondArg = Arg;
1661 if (Arg.getKind() == TemplateArgument::Template)
1664 Arg.getAsTemplate(), Info, Deduced);
1666 Info.SecondArg = Arg;
1673 if (Arg.getKind() == TemplateArgument::Declaration &&
1674 isSameDeclaration(Param.getAsDecl(), Arg.getAsDecl()) &&
1675 Param.isDeclForReferenceParam() == Arg.isDeclForReferenceParam())
1679 Info.SecondArg = Arg;
1683 if (Arg.getKind() == TemplateArgument::NullPtr &&
1684 S.Context.hasSameType(Param.getNullPtrType(), Arg.getNullPtrType()))
1688 Info.SecondArg = Arg;
1692 if (Arg.getKind() == TemplateArgument::Integral) {
1693 if (hasSameExtendedValue(Param.getAsIntegral(), Arg.getAsIntegral()))
1697 Info.SecondArg = Arg;
1701 if (Arg.getKind() == TemplateArgument::Expression) {
1703 Info.SecondArg = Arg;
1708 Info.SecondArg = Arg;
1714 if (Arg.getKind() == TemplateArgument::Integral)
1716 Arg.getAsIntegral(),
1717 Arg.getIntegralType(),
1720 if (Arg.getKind() == TemplateArgument::Expression)
1721 return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsExpr(),
1723 if (Arg.getKind() == TemplateArgument::Declaration)
1724 return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsDecl(),
1728 Info.SecondArg = Arg;
1756 const TemplateArgument &Arg = Args[ArgIdx];
1757 if (Arg.getKind() != TemplateArgument::Pack)
1761 Args = Arg.pack_begin();
1762 NumArgs = Arg.pack_size();
1773 const TemplateArgument &Arg = Args[ArgIdx];
1777 Args = Arg.pack_begin();
1778 NumArgs = Arg.pack_size();
1787 if (Arg.isPackExpansion())
1992 /// \param Arg The template argument we are producing template argument
2003 const TemplateArgument &Arg,
2006 switch (Arg.getKind()) {
2011 return TemplateArgumentLoc(Arg,
2012 S.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc));
2016 = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc)
2023 = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc)
2031 = S.BuildExpressionFromIntegralTemplateArgument(Arg, Loc).takeAs<Expr>();
2038 TemplateName Template = Arg.getAsTemplate();
2044 if (Arg.getKind() == TemplateArgument::Template)
2045 return TemplateArgumentLoc(Arg,
2050 return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(S.Context),
2055 return TemplateArgumentLoc(Arg, Arg.getAsExpr());
2058 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo());
2069 DeducedTemplateArgument Arg,
2076 if (Arg.getKind() == TemplateArgument::Pack) {
2080 for (TemplateArgument::pack_iterator PA = Arg.pack_begin(),
2081 PAEnd = Arg.pack_end();
2087 InnerArg.setDeducedFromArrayBound(Arg.wasDeducedFromArrayBound());
2108 TemplateArgumentLoc ArgLoc = getTrivialTemplateArgumentLoc(S, Arg, NTTPType,
2119 ? (Arg.wasDeducedFromArrayBound()
2454 /// given function template according to C++ [temp.arg.explicit].
2507 // C++ [temp.arg.explicit]p3:
2554 const TemplateArgument &Arg = Builder[I];
2555 if (Arg.getKind() == TemplateArgument::Pack) {
2558 Arg.pack_begin(),
2559 Arg.pack_size());
2626 // C++ [temp.arg.explicit]p2:
2638 const TemplateArgument &Arg = ExplicitArgumentList->get(I);
2639 if (Arg.getKind() == TemplateArgument::Pack)
2642 Deduced.push_back(Arg);
2836 // C++0x [temp.arg.explicit]p3:
2843 // explicitly-specified set (C++0x [temp.arg.explicit]p9).
2992 Expr *Arg, QualType ParamType,
2995 OverloadExpr::FindResult R = OverloadExpr::find(Arg);
3094 Expr *Arg,
3106 if (ArgType->isIncompleteArrayType() && !S.RequireCompleteExprType(Arg, 0))
3107 ArgType = Arg->getType();
3116 Arg->Classify(S.Context).isLValue() &&
3117 Arg->getType() != S.Context.OverloadTy &&
3118 Arg->getType() != S.Context.BoundMemberTy)
3131 Arg, ParamType,
3144 Arg->isLValue())
3208 QualType ParamType, Expr *Arg,
3214 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) {
3231 QualType ArgType = Arg->getType();
3233 ArgType, Arg, TDF)) {
3234 Info.Expression = Arg;
3331 Expr *Arg = Args[ArgIdx++];
3332 QualType ArgType = Arg->getType();
3336 ParamType, ArgType, Arg,
3345 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) {
3423 Expr *Arg = Args[ArgIdx];
3424 QualType ArgType = Arg->getType();
3428 ParamType, ArgType, Arg,
3437 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) {
3508 /// argument type to compare against, in C++0x [temp.arg.explicit]p3.
3712 /// nothing to deduce against (C++0x [temp.arg.explicit]p3).
