Lines Matching defs:Canonical
558 const Decl *Canonical = D->getCanonicalDecl();
560 ParsedComments.find(Canonical);
563 if (Canonical != D) {
654 ParsedComments[Canonical] = FC;
678 /*Canonical=*/true);
710 RequiresClause->Profile(ID, C, /*Canonical=*/true);
767 // Check if we already have a canonical template template parameter.
771 CanonicalTemplateTemplateParm *Canonical
773 if (Canonical)
774 return Canonical->getParam();
776 // Build a canonical template parameter list.
873 Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
874 assert(!Canonical && "Shouldn't be in the map!");
875 (void)Canonical;
877 // Create the canonical template template parameter entry.
878 Canonical = new (*this) CanonicalTemplateTemplateParm(CanonTTP);
879 CanonTemplateTemplateParms.InsertNode(Canonical, InsertPos);
2926 // If the base type is not canonical, make the appropriate canonical type.
3171 // If the pointee type isn't canonical, this won't be a canonical type either,
3172 // so fill in the canonical type field.
3173 QualType Canonical;
3175 Canonical = getComplexType(getCanonicalType(T));
3181 auto *New = new (*this, TypeAlignment) ComplexType(T, Canonical);
3199 // If the pointee type isn't canonical, this won't be a canonical type either,
3200 // so fill in the canonical type field.
3201 QualType Canonical;
3203 Canonical = getPointerType(getCanonicalType(T));
3209 auto *New = new (*this, TypeAlignment) PointerType(T, Canonical);
3223 QualType Canonical = getCanonicalType(New);
3230 AdjustedType(Type::Adjusted, Orig, New, Canonical);
3263 QualType Canonical = getCanonicalType(Decayed);
3269 AT = new (*this, TypeAlignment) DecayedType(T, Decayed, Canonical);
3289 // If the block pointee type isn't canonical, this won't be a canonical
3290 // type either so fill in the canonical type field.
3291 QualType Canonical;
3293 Canonical = getBlockPointerType(getCanonicalType(T));
3300 auto *New = new (*this, TypeAlignment) BlockPointerType(T, Canonical);
3325 // If the referencee type isn't canonical, this won't be a canonical type
3326 // either, so fill in the canonical type field.
3327 QualType Canonical;
3330 Canonical = getLValueReferenceType(getCanonicalType(PointeeType));
3338 auto *New = new (*this, TypeAlignment) LValueReferenceType(T, Canonical,
3361 // If the referencee type isn't canonical, this won't be a canonical type
3362 // either, so fill in the canonical type field.
3363 QualType Canonical;
3366 Canonical = getRValueReferenceType(getCanonicalType(PointeeType));
3374 auto *New = new (*this, TypeAlignment) RValueReferenceType(T, Canonical);
3393 // If the pointee or class type isn't canonical, this won't be a canonical
3394 // type either, so fill in the canonical type field.
3395 QualType Canonical;
3397 Canonical = getMemberPointerType(getCanonicalType(T),getCanonicalType(Cls));
3404 auto *New = new (*this, TypeAlignment) MemberPointerType(T, Cls, Canonical);
3425 // Convert the array size into a canonical width matching the pointer size for
3439 // If the element type isn't canonical or has qualifiers, or the array bound
3440 // is instantiation-dependent, this won't be a canonical type either, so fill
3441 // in the canonical type field.
3481 canonical types?");
3660 // also build a canonical type.
3715 // If the element type isn't canonical, this won't be a canonical type
3716 // either, so fill in the canonical type field. We also have to pull
3921 // If the element type isn't canonical, this won't be a canonical type either,
3922 // so fill in the canonical type field.
3923 QualType Canonical;
3925 Canonical = getVectorType(getCanonicalType(vecType), NumElts, VecKind);
3932 VectorType(vecType, NumElts, Canonical, VecKind);
3962 "Dependent-sized vector_size canonical type broken");
3991 // If the element type isn't canonical, this won't be a canonical type either,
3992 // so fill in the canonical type field.
3993 QualType Canonical;
3995 Canonical = getExtVectorType(getCanonicalType(vecType), NumElts);
4002 ExtVectorType(vecType, NumElts, Canonical);
4021 // We already have a canonical version of this array type; use it as
4022 // the canonical type for a newly-built type.
4035 assert(!CanonCheck && "Dependent-sized ext_vector canonical type broken");
4065 QualType Canonical;
4067 Canonical =
4076 ConstantMatrixType(ElementTy, NumRows, NumColumns, Canonical);
4101 assert(!CanonCheck && "Dependent-sized matrix canonical type broken");
4107 // Already have a canonical version of the matrix type
4114 // Use Canon as the canonical type for newly-built type.
4157 /// Determine whether \p T is canonical as the result type of a function.
4178 QualType Canonical;
4180 Canonical =
4190 FunctionNoProtoType(ResultTy, Canonical, Info);
4200 // Canonical result types do not have ARC lifetime qualifiers.
4223 // A noexcept(expr) specification is (possibly) canonical if expr is
4228 // A dynamic exception specification is canonical if it only contains pack
4230 // contained types are canonical.
4256 QualType Canonical;
4266 // noexcept expression, or we're just looking for a canonical type.
4276 Canonical = getCanonicalType(Existing);
4284 // Determine whether the type being created is already canonical or not.
4293 "given non-canonical parameters constructing canonical type");
4295 // If this type isn't canonical, get the canonical version of it if we don't
4297 // canonical type, and only in C++17 onwards.
4298 if (!isCanonical && Canonical.isNull()) {
4346 llvm_unreachable("dependent noexcept is already canonical");
4352 // Adjust the canonical function result type.
4354 Canonical =
4379 new (FTP) FunctionProtoType(ResultTy, ArgArray, Canonical, newEPI);
4394 // If the pipe element type isn't canonical, this won't be a canonical type
4395 // either, so fill in the canonical type field.
4396 QualType Canonical;
4398 Canonical = getPipeType(getCanonicalType(T), ReadOnly);
4405 auto *New = new (*this, TypeAlignment) PipeType(T, Canonical, ReadOnly);
4528 QualType Canonical = getCanonicalType(Underlying);
4530 TypedefType(Type::Typedef, Decl, Underlying, Canonical);
4587 && "replacement types must always be canonical");
4612 assert(P.getAsType().isCanonical() && "Pack contains non-canonical type");
4660 assert(!TypeCheck && "Template type parameter canonical type broken");
4743 // Allocate the (non-canonical) template specialization type, but don't
4767 // Build the canonical template specialization type.
4775 // Determine whether this canonical template specialization type already
4786 // Allocate a new canonical template specialization type.
4798 "Non-dependent template-id type must have a canonical type");
4818 assert(!CheckT && "Elaborated canonical type broken");
4845 assert(!CheckT && "Paren canonical type broken");
5107 // Build the canonical type, which has the canonical base type and a
5110 QualType canonical;
5118 // Determine the canonical type arguments.
5140 canonical = getObjCObjectType(getCanonicalType(baseType), canonTypeArgs,
5152 new (mem) ObjCObjectTypeImpl(canonical, baseType, typeArgs, protocols,
5161 /// If this is for the canonical type of a type parameter, we can apply
5204 // If the canonical type is ObjCObjectType, ...
5246 QualType Canonical = getCanonicalType(Decl->getUnderlyingType());
5250 Canonical = getCanonicalType(applyObjCProtocolQualifiers(
5251 Canonical, protocols, hasError, true /*allowOnPointerType*/));
5258 auto *newType = new (mem) ObjCTypeParamType(Decl, Canonical, protocols);
5353 // Find the canonical object type.
5354 QualType Canonical;
5356 Canonical = getObjCObjectPointerType(getCanonicalType(ObjectT));
5365 new (Mem) ObjCObjectPointerType(Canonical, ObjectT);
5400 /// on canonical type's (which are always unique).
5411 // We already have a "canonical" version of an identical, dependent
5412 // typeof(expr) type. Use that as our canonical type.
5416 // Build a new, canonical typeof(expr) type.
5423 QualType Canonical = getCanonicalType(tofExpr->getType());
5424 toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, Canonical);
5434 /// on canonical types (which are always unique).
5436 QualType Canonical = getCanonicalType(tofType);
5437 auto *tot = new (*this, TypeAlignment) TypeOfType(tofType, Canonical);
5461 // Build a new, canonical decltype(expr) type.
5493 // Build a new, canonical __underlying_type(type) type.
5513 /// deduced to the given type, or to the canonical undeduced 'auto' type, or the
5514 /// canonical deduced-but-dependent 'auto' type.
5549 /// which has been deduced to the given type, or to the canonical undeduced
5550 /// such type, or the canonical deduced-but-dependent such type.
5582 // If the atomic value type isn't canonical, this won't be a canonical type
5583 // either, so fill in the canonical type field.
5584 QualType Canonical;
5586 Canonical = getAtomicType(getCanonicalType(T));
5592 auto *New = new (*this, TypeAlignment) AtomicType(T, Canonical);
5938 // The canonical template name is the canonical template declaration.
6042 // A namespace is canonical; build a nested-name-specifier with
6048 // A namespace is canonical; build a nested-name-specifier with
6060 // as the canonical nested-name-specifier. This is required to canonicalize
6078 // The global specifier and __super specifer are canonical and unique.
6170 /// handling typedefs etc. The canonical type of "T" must be an array type,
9697 // If the canonical type classes don't match.
9718 // The canonical type classes match.
9726 llvm_unreachable("Non-canonical and dependent types shouldn't get here");
Indexes created Sun May 03 00:22:47 UTC 2026