Lines Matching refs:Canonical
99 // Check if we already have a canonical template template parameter.
103 CanonicalTemplateTemplateParm *Canonical
105 if (Canonical)
106 return Canonical->getParam();
108 // Build a canonical template parameter list.
177 Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
178 assert(Canonical == 0 && "Shouldn't be in the map!");
179 (void)Canonical;
181 // Create the canonical template template parameter entry.
182 Canonical = new (*this) CanonicalTemplateTemplateParm(CanonTTP);
183 CanonTemplateTemplateParms.InsertNode(Canonical, InsertPos);
1398 // If the base type is not canonical, make the appropriate canonical type.
1493 // If the pointee type isn't canonical, this won't be a canonical type either,
1494 // so fill in the canonical type field.
1495 QualType Canonical;
1497 Canonical = getComplexType(getCanonicalType(T));
1503 ComplexType *New = new (*this, TypeAlignment) ComplexType(T, Canonical);
1521 // If the pointee type isn't canonical, this won't be a canonical type either,
1522 // so fill in the canonical type field.
1523 QualType Canonical;
1525 Canonical = getPointerType(getCanonicalType(T));
1531 PointerType *New = new (*this, TypeAlignment) PointerType(T, Canonical);
1551 // If the block pointee type isn't canonical, this won't be a canonical
1552 // type either so fill in the canonical type field.
1553 QualType Canonical;
1555 Canonical = getBlockPointerType(getCanonicalType(T));
1563 = new (*this, TypeAlignment) BlockPointerType(T, Canonical);
1588 // If the referencee type isn't canonical, this won't be a canonical type
1589 // either, so fill in the canonical type field.
1590 QualType Canonical;
1593 Canonical = getLValueReferenceType(getCanonicalType(PointeeType));
1602 = new (*this, TypeAlignment) LValueReferenceType(T, Canonical,
1625 // If the referencee type isn't canonical, this won't be a canonical type
1626 // either, so fill in the canonical type field.
1627 QualType Canonical;
1630 Canonical = getRValueReferenceType(getCanonicalType(PointeeType));
1639 = new (*this, TypeAlignment) RValueReferenceType(T, Canonical);
1658 // If the pointee or class type isn't canonical, this won't be a canonical
1659 // type either, so fill in the canonical type field.
1660 QualType Canonical;
1662 Canonical = getMemberPointerType(getCanonicalType(T),getCanonicalType(Cls));
1670 = new (*this, TypeAlignment) MemberPointerType(T, Cls, Canonical);
1686 // Convert the array size into a canonical width matching the pointer size for
1700 // If the element type isn't canonical or has qualifiers, this won't
1701 // be a canonical type either, so fill in the canonical type field.
1738 llvm_unreachable("didn't desugar past all non-canonical types?");
1908 // also build a canonical type.
1962 // If the element type isn't canonical, this won't be a canonical type
1963 // either, so fill in the canonical type field. We also have to pull
2001 // If the element type isn't canonical, this won't be a canonical type either,
2002 // so fill in the canonical type field.
2003 QualType Canonical;
2005 Canonical = getVectorType(getCanonicalType(vecType), NumElts, VecKind);
2012 VectorType(vecType, NumElts, Canonical, VecKind);
2032 // If the element type isn't canonical, this won't be a canonical type either,
2033 // so fill in the canonical type field.
2034 QualType Canonical;
2036 Canonical = getExtVectorType(getCanonicalType(vecType), NumElts);
2043 ExtVectorType(vecType, NumElts, Canonical);
2062 // We already have a canonical version of this array type; use it as
2063 // the canonical type for a newly-built type.
2076 assert(!CanonCheck && "Dependent-sized ext_vector canonical type broken");
2109 QualType Canonical;
2112 Canonical =
2124 FunctionNoProtoType(ResultTy, Canonical, newInfo);
2146 // Determine whether the type being created is already canonical or not.
2158 // If this type isn't canonical, get the canonical version of it.
2159 // The exception spec is not part of the canonical type.
2160 QualType Canonical;
2174 Canonical = getFunctionType(getCanonicalType(ResultTy),
2206 new (FTP) FunctionProtoType(ResultTy, ArgArray, NumArgs, Canonical, newEPI);
2281 QualType Canonical) const {
2284 if (Canonical.isNull())
2285 Canonical = getCanonicalType(Decl->getUnderlyingType());
2287 TypedefType(Type::Typedef, Decl, Canonical);
2345 && "replacement types must always be canonical");
2372 assert(P->getAsType().isCanonical() && "Pack contains non-canonical type");
2420 assert(!TypeCheck && "Template type parameter canonical type broken");
2509 // Allocate the (non-canonical) template specialization type, but don't
2535 // Build the canonical template specialization type.
2542 // Determine whether this canonical template specialization type already
2553 // Allocate a new canonical template specialization type.
2565 "Non-dependent template-id type must have a canonical type");
2585 assert(!CheckT && "Elaborated canonical type broken");
2609 assert(!CheckT && "Paren canonical type broken");
2797 // Build the canonical type, which has the canonical base type and
2799 QualType Canonical;
2808 Canonical = getObjCObjectType(getCanonicalType(BaseType),
2811 Canonical = getObjCObjectType(getCanonicalType(BaseType),
2823 new (Mem) ObjCObjectTypeImpl(Canonical, BaseType, Protocols, NumProtocols);
2841 // Find the canonical object type.
2842 QualType Canonical;
2844 Canonical = getObjCObjectPointerType(getCanonicalType(ObjectT));
2853 new (Mem) ObjCObjectPointerType(Canonical, ObjectT);
2888 /// on canonical type's (which are always unique).
2899 // We already have a "canonical" version of an identical, dependent
2900 // typeof(expr) type. Use that as our canonical type.
2904 // Build a new, canonical typeof(expr) type.
2911 QualType Canonical = getCanonicalType(tofExpr->getType());
2912 toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, Canonical);
2922 /// on canonical type's (which are always unique).
2924 QualType Canonical = getCanonicalType(tofType);
2925 TypeOfType *tot = new (*this, TypeAlignment) TypeOfType(tofType, Canonical);
2935 /// on canonical types (which are always unique).
2951 // We already have a "canonical" version of an equivalent, dependent
2952 // decltype type. Use that as our canonical type.
2956 // Build a new, canonical typeof(expr) type.
3014 // If the atomic value type isn't canonical, this won't be a canonical type
3015 // either, so fill in the canonical type field.
3016 QualType Canonical;
3018 Canonical = getAtomicType(getCanonicalType(T));
3024 AtomicType *New = new (*this, TypeAlignment) AtomicType(T, Canonical);
3271 // The canonical template name is the canonical template declaration.
3373 // A namespace is canonical; build a nested-name-specifier with
3379 // A namespace is canonical; build a nested-name-specifier with
3391 // as the canonical nested-name-specifier. This is required to canonicalize
3408 // The global specifier is canonical and unique.
3501 /// handling typedefs etc. The canonical type of "T" must be an array type,
5925 // If the canonical type classes don't match.
5952 // The canonical type classes match.
5960 llvm_unreachable("Non-canonical and dependent types shouldn't get here");
