granicus.if.org Git - clang/blob - lib/AST/TypeLoc.cpp

   1 //===--- TypeLoc.cpp - Type Source Info Wrapper -----------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file defines the TypeLoc subclasses implementations.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/AST/TypeLoc.h"
  15 #include "clang/AST/ASTContext.h"
  16 #include "clang/AST/Expr.h"
  17 #include "clang/AST/TypeLocVisitor.h"
  18 #include "llvm/Support/ErrorHandling.h"
  19 #include "llvm/Support/raw_ostream.h"
  20 using namespace clang;
  21
  22 static const unsigned TypeLocMaxDataAlign = llvm::alignOf<void *>();
  23
  24 //===----------------------------------------------------------------------===//
  25 // TypeLoc Implementation
  26 //===----------------------------------------------------------------------===//
  27
  28 namespace {
  29   class TypeLocRanger : public TypeLocVisitor<TypeLocRanger, SourceRange> {
  30   public:
  31 #define ABSTRACT_TYPELOC(CLASS, PARENT)
  32 #define TYPELOC(CLASS, PARENT) \
  33     SourceRange Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) { \
  34       return TyLoc.getLocalSourceRange(); \
  35     }
  36 #include "clang/AST/TypeLocNodes.def"
  37   };
  38 }
  39
  40 SourceRange TypeLoc::getLocalSourceRangeImpl(TypeLoc TL) {
  41   if (TL.isNull()) return SourceRange();
  42   return TypeLocRanger().Visit(TL);
  43 }
  44
  45 namespace {
  46   class TypeAligner : public TypeLocVisitor<TypeAligner, unsigned> {
  47   public:
  48 #define ABSTRACT_TYPELOC(CLASS, PARENT)
  49 #define TYPELOC(CLASS, PARENT) \
  50     unsigned Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) { \
  51       return TyLoc.getLocalDataAlignment(); \
  52     }
  53 #include "clang/AST/TypeLocNodes.def"
  54   };
  55 }
  56
  57 /// \brief Returns the alignment of the type source info data block.
  58 unsigned TypeLoc::getLocalAlignmentForType(QualType Ty) {
  59   if (Ty.isNull()) return 1;
  60   return TypeAligner().Visit(TypeLoc(Ty, nullptr));
  61 }
  62
  63 namespace {
  64   class TypeSizer : public TypeLocVisitor<TypeSizer, unsigned> {
  65   public:
  66 #define ABSTRACT_TYPELOC(CLASS, PARENT)
  67 #define TYPELOC(CLASS, PARENT) \
  68     unsigned Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) { \
  69       return TyLoc.getLocalDataSize(); \
  70     }
  71 #include "clang/AST/TypeLocNodes.def"
  72   };
  73 }
  74
  75 /// \brief Returns the size of the type source info data block.
  76 unsigned TypeLoc::getFullDataSizeForType(QualType Ty) {
  77   unsigned Total = 0;
  78   TypeLoc TyLoc(Ty, nullptr);
  79   unsigned MaxAlign = 1;
  80   while (!TyLoc.isNull()) {
  81     unsigned Align = getLocalAlignmentForType(TyLoc.getType());
  82     MaxAlign = std::max(Align, MaxAlign);
  83     Total = llvm::alignTo(Total, Align);
  84     Total += TypeSizer().Visit(TyLoc);
  85     TyLoc = TyLoc.getNextTypeLoc();
  86   }
  87   Total = llvm::alignTo(Total, MaxAlign);
  88   return Total;
  89 }
  90
  91 namespace {
  92   class NextLoc : public TypeLocVisitor<NextLoc, TypeLoc> {
  93   public:
  94 #define ABSTRACT_TYPELOC(CLASS, PARENT)
  95 #define TYPELOC(CLASS, PARENT) \
  96     TypeLoc Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) { \
  97       return TyLoc.getNextTypeLoc(); \
  98     }
  99 #include "clang/AST/TypeLocNodes.def"
 100   };
 101 }
 102
 103 /// \brief Get the next TypeLoc pointed by this TypeLoc, e.g for "int*" the
 104 /// TypeLoc is a PointerLoc and next TypeLoc is for "int".
 105 TypeLoc TypeLoc::getNextTypeLocImpl(TypeLoc TL) {
 106   return NextLoc().Visit(TL);
 107 }
 108
 109 /// \brief Initializes a type location, and all of its children
 110 /// recursively, as if the entire tree had been written in the
 111 /// given location.
 112 void TypeLoc::initializeImpl(ASTContext &Context, TypeLoc TL,
 113                              SourceLocation Loc) {
 114   while (true) {
 115     switch (TL.getTypeLocClass()) {
 116 #define ABSTRACT_TYPELOC(CLASS, PARENT)
 117 #define TYPELOC(CLASS, PARENT)        \
 118     case CLASS: {                     \
 119       CLASS##TypeLoc TLCasted = TL.castAs<CLASS##TypeLoc>(); \
 120       TLCasted.initializeLocal(Context, Loc);  \
 121       TL = TLCasted.getNextTypeLoc(); \
 122       if (!TL) return;                \
 123       continue;                       \
 124     }
 125 #include "clang/AST/TypeLocNodes.def"
 126     }
 127   }
 128 }
 129
 130 namespace {
 131   class TypeLocCopier : public TypeLocVisitor<TypeLocCopier> {
 132     TypeLoc Source;
 133   public:
 134     TypeLocCopier(TypeLoc source) : Source(source) { }
 135
 136 #define ABSTRACT_TYPELOC(CLASS, PARENT)
 137 #define TYPELOC(CLASS, PARENT)                          \
 138     void Visit##CLASS##TypeLoc(CLASS##TypeLoc dest) {   \
 139       dest.copyLocal(Source.castAs<CLASS##TypeLoc>());  \
 140     }
 141 #include "clang/AST/TypeLocNodes.def"
 142   };
 143 }
 144
 145
 146 void TypeLoc::copy(TypeLoc other) {
 147   assert(getFullDataSize() == other.getFullDataSize());
 148
 149   // If both data pointers are aligned to the maximum alignment, we
 150   // can memcpy because getFullDataSize() accurately reflects the
 151   // layout of the data.
 152   if (reinterpret_cast<uintptr_t>(Data) ==
 153           llvm::alignTo(reinterpret_cast<uintptr_t>(Data),
 154                         TypeLocMaxDataAlign) &&
 155       reinterpret_cast<uintptr_t>(other.Data) ==
 156           llvm::alignTo(reinterpret_cast<uintptr_t>(other.Data),
 157                         TypeLocMaxDataAlign)) {
 158     memcpy(Data, other.Data, getFullDataSize());
 159     return;
 160   }
 161
 162   // Copy each of the pieces.
 163   TypeLoc TL(getType(), Data);
 164   do {
 165     TypeLocCopier(other).Visit(TL);
 166     other = other.getNextTypeLoc();
 167   } while ((TL = TL.getNextTypeLoc()));
 168 }
 169
 170 SourceLocation TypeLoc::getBeginLoc() const {
 171   TypeLoc Cur = *this;
 172   TypeLoc LeftMost = Cur;
 173   while (true) {
 174     switch (Cur.getTypeLocClass()) {
 175     case Elaborated:
 176       LeftMost = Cur;
 177       break;
 178     case FunctionProto:
 179       if (Cur.castAs<FunctionProtoTypeLoc>().getTypePtr()
 180               ->hasTrailingReturn()) {
 181         LeftMost = Cur;
 182         break;
 183       }
 184       /* Fall through */
 185     case FunctionNoProto:
 186     case ConstantArray:
 187     case DependentSizedArray:
 188     case IncompleteArray:
 189     case VariableArray:
 190       // FIXME: Currently QualifiedTypeLoc does not have a source range
 191     case Qualified:
 192       Cur = Cur.getNextTypeLoc();
 193       continue;
 194     default:
 195       if (Cur.getLocalSourceRange().getBegin().isValid())
 196         LeftMost = Cur;
 197       Cur = Cur.getNextTypeLoc();
 198       if (Cur.isNull())
 199         break;
 200       continue;
 201     } // switch
 202     break;
 203   } // while
 204   return LeftMost.getLocalSourceRange().getBegin();
 205 }
 206
 207 SourceLocation TypeLoc::getEndLoc() const {
 208   TypeLoc Cur = *this;
 209   TypeLoc Last;
 210   while (true) {
 211     switch (Cur.getTypeLocClass()) {
 212     default:
 213       if (!Last)
 214         Last = Cur;
 215       return Last.getLocalSourceRange().getEnd();
 216     case Paren:
 217     case ConstantArray:
 218     case DependentSizedArray:
 219     case IncompleteArray:
 220     case VariableArray:
 221     case FunctionNoProto:
 222       Last = Cur;
 223       break;
 224     case FunctionProto:
 225       if (Cur.castAs<FunctionProtoTypeLoc>().getTypePtr()->hasTrailingReturn())
 226         Last = TypeLoc();
 227       else
 228         Last = Cur;
 229       break;
 230     case Pointer:
 231     case BlockPointer:
 232     case MemberPointer:
 233     case LValueReference:
 234     case RValueReference:
 235     case PackExpansion:
 236       if (!Last)
 237         Last = Cur;
 238       break;
 239     case Qualified:
 240     case Elaborated:
 241       break;
 242     }
 243     Cur = Cur.getNextTypeLoc();
 244   }
 245 }
 246
 247
 248 namespace {
 249   struct TSTChecker : public TypeLocVisitor<TSTChecker, bool> {
 250     // Overload resolution does the real work for us.
 251     static bool isTypeSpec(TypeSpecTypeLoc _) { return true; }
 252     static bool isTypeSpec(TypeLoc _) { return false; }
 253
 254 #define ABSTRACT_TYPELOC(CLASS, PARENT)
 255 #define TYPELOC(CLASS, PARENT) \
 256     bool Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) { \
 257       return isTypeSpec(TyLoc); \
 258     }
 259 #include "clang/AST/TypeLocNodes.def"
 260   };
 261 }
 262
 263
 264 /// \brief Determines if the given type loc corresponds to a
 265 /// TypeSpecTypeLoc.  Since there is not actually a TypeSpecType in
 266 /// the type hierarchy, this is made somewhat complicated.
 267 ///
 268 /// There are a lot of types that currently use TypeSpecTypeLoc
 269 /// because it's a convenient base class.  Ideally we would not accept
 270 /// those here, but ideally we would have better implementations for
 271 /// them.
 272 bool TypeSpecTypeLoc::isKind(const TypeLoc &TL) {
 273   if (TL.getType().hasLocalQualifiers()) return false;
 274   return TSTChecker().Visit(TL);
 275 }
 276
 277 // Reimplemented to account for GNU/C++ extension
 278 //     typeof unary-expression
 279 // where there are no parentheses.
 280 SourceRange TypeOfExprTypeLoc::getLocalSourceRange() const {
 281   if (getRParenLoc().isValid())
 282     return SourceRange(getTypeofLoc(), getRParenLoc());
 283   else
 284     return SourceRange(getTypeofLoc(),
 285                        getUnderlyingExpr()->getSourceRange().getEnd());
 286 }
 287
 288
 289 TypeSpecifierType BuiltinTypeLoc::getWrittenTypeSpec() const {
 290   if (needsExtraLocalData())
 291     return static_cast<TypeSpecifierType>(getWrittenBuiltinSpecs().Type);
 292   switch (getTypePtr()->getKind()) {
 293   case BuiltinType::Void:
 294     return TST_void;
 295   case BuiltinType::Bool:
 296     return TST_bool;
 297   case BuiltinType::Char_U:
 298   case BuiltinType::Char_S:
 299     return TST_char;
 300   case BuiltinType::Char16:
 301     return TST_char16;
 302   case BuiltinType::Char32:
 303     return TST_char32;
 304   case BuiltinType::WChar_S:
 305   case BuiltinType::WChar_U:
 306     return TST_wchar;
 307   case BuiltinType::UChar:
 308   case BuiltinType::UShort:
 309   case BuiltinType::UInt:
 310   case BuiltinType::ULong:
 311   case BuiltinType::ULongLong:
 312   case BuiltinType::UInt128:
 313   case BuiltinType::SChar:
 314   case BuiltinType::Short:
 315   case BuiltinType::Int:
 316   case BuiltinType::Long:
 317   case BuiltinType::LongLong:
 318   case BuiltinType::Int128:
 319   case BuiltinType::Half:
 320   case BuiltinType::Float:
 321   case BuiltinType::Double:
 322   case BuiltinType::LongDouble:
 323   case BuiltinType::Float128:
 324     llvm_unreachable("Builtin type needs extra local data!");
 325     // Fall through, if the impossible happens.
 326
 327   case BuiltinType::NullPtr:
 328   case BuiltinType::Overload:
 329   case BuiltinType::Dependent:
 330   case BuiltinType::BoundMember:
 331   case BuiltinType::UnknownAny:
 332   case BuiltinType::ARCUnbridgedCast:
 333   case BuiltinType::PseudoObject:
 334   case BuiltinType::ObjCId:
 335   case BuiltinType::ObjCClass:
 336   case BuiltinType::ObjCSel:
 337 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
 338   case BuiltinType::Id:
 339 #include "clang/Basic/OpenCLImageTypes.def"
 340   case BuiltinType::OCLSampler:
 341   case BuiltinType::OCLEvent:
 342   case BuiltinType::OCLClkEvent:
 343   case BuiltinType::OCLQueue:
 344   case BuiltinType::OCLNDRange:
 345   case BuiltinType::OCLReserveID:
 346   case BuiltinType::BuiltinFn:
 347   case BuiltinType::OMPArraySection:
 348     return TST_unspecified;
 349   }
 350
 351   llvm_unreachable("Invalid BuiltinType Kind!");
 352 }
 353
 354 TypeLoc TypeLoc::IgnoreParensImpl(TypeLoc TL) {
 355   while (ParenTypeLoc PTL = TL.getAs<ParenTypeLoc>())
 356     TL = PTL.getInnerLoc();
 357   return TL;
 358 }
 359
 360 SourceLocation TypeLoc::findNullabilityLoc() const {
 361   if (auto attributedLoc = getAs<AttributedTypeLoc>()) {
 362     if (attributedLoc.getAttrKind() == AttributedType::attr_nullable ||
 363         attributedLoc.getAttrKind() == AttributedType::attr_nonnull ||
 364         attributedLoc.getAttrKind() == AttributedType::attr_null_unspecified)
 365       return attributedLoc.getAttrNameLoc();
 366   }
 367
 368   return SourceLocation();
 369 }
 370
 371 TypeLoc TypeLoc::findExplicitQualifierLoc() const {
 372   // Qualified types.
 373   if (auto qual = getAs<QualifiedTypeLoc>())
 374     return qual;
 375
 376   TypeLoc loc = IgnoreParens();
 377
 378   // Attributed types.
 379   if (auto attr = loc.getAs<AttributedTypeLoc>()) {
 380     if (attr.isQualifier()) return attr;
 381     return attr.getModifiedLoc().findExplicitQualifierLoc();
 382   }
 383
 384   // C11 _Atomic types.
 385   if (auto atomic = loc.getAs<AtomicTypeLoc>()) {
 386     return atomic;
 387   }
 388
 389   return TypeLoc();
 390 }
 391
 392 void ObjCObjectTypeLoc::initializeLocal(ASTContext &Context,
 393                                         SourceLocation Loc) {
 394   setHasBaseTypeAsWritten(true);
 395   setTypeArgsLAngleLoc(Loc);
 396   setTypeArgsRAngleLoc(Loc);
 397   for (unsigned i = 0, e = getNumTypeArgs(); i != e; ++i) {
 398     setTypeArgTInfo(i,
 399                    Context.getTrivialTypeSourceInfo(
 400                      getTypePtr()->getTypeArgsAsWritten()[i], Loc));
 401   }
 402   setProtocolLAngleLoc(Loc);
 403   setProtocolRAngleLoc(Loc);
 404   for (unsigned i = 0, e = getNumProtocols(); i != e; ++i)
 405     setProtocolLoc(i, Loc);
 406 }
 407
 408 void TypeOfTypeLoc::initializeLocal(ASTContext &Context,
 409                                        SourceLocation Loc) {
 410   TypeofLikeTypeLoc<TypeOfTypeLoc, TypeOfType, TypeOfTypeLocInfo>
 411       ::initializeLocal(Context, Loc);
 412   this->getLocalData()->UnderlyingTInfo = Context.getTrivialTypeSourceInfo(
 413       getUnderlyingType(), Loc);
 414 }
 415
 416 void ElaboratedTypeLoc::initializeLocal(ASTContext &Context,
 417                                         SourceLocation Loc) {
 418   setElaboratedKeywordLoc(Loc);
 419   NestedNameSpecifierLocBuilder Builder;
 420   Builder.MakeTrivial(Context, getTypePtr()->getQualifier(), Loc);
 421   setQualifierLoc(Builder.getWithLocInContext(Context));
 422 }
 423
 424 void DependentNameTypeLoc::initializeLocal(ASTContext &Context,
 425                                            SourceLocation Loc) {
 426   setElaboratedKeywordLoc(Loc);
 427   NestedNameSpecifierLocBuilder Builder;
 428   Builder.MakeTrivial(Context, getTypePtr()->getQualifier(), Loc);
 429   setQualifierLoc(Builder.getWithLocInContext(Context));
 430   setNameLoc(Loc);
 431 }
 432
 433 void
 434 DependentTemplateSpecializationTypeLoc::initializeLocal(ASTContext &Context,
 435                                                         SourceLocation Loc) {
 436   setElaboratedKeywordLoc(Loc);
 437   if (getTypePtr()->getQualifier()) {
 438     NestedNameSpecifierLocBuilder Builder;
 439     Builder.MakeTrivial(Context, getTypePtr()->getQualifier(), Loc);
 440     setQualifierLoc(Builder.getWithLocInContext(Context));
 441   } else {
 442     setQualifierLoc(NestedNameSpecifierLoc());
 443   }
 444   setTemplateKeywordLoc(Loc);
 445   setTemplateNameLoc(Loc);
 446   setLAngleLoc(Loc);
 447   setRAngleLoc(Loc);
 448   TemplateSpecializationTypeLoc::initializeArgLocs(Context, getNumArgs(),
 449                                                    getTypePtr()->getArgs(),
 450                                                    getArgInfos(), Loc);
 451 }
 452
 453 void TemplateSpecializationTypeLoc::initializeArgLocs(ASTContext &Context,
 454                                                       unsigned NumArgs,
 455                                                   const TemplateArgument *Args,
 456                                               TemplateArgumentLocInfo *ArgInfos,
 457                                                       SourceLocation Loc) {
 458   for (unsigned i = 0, e = NumArgs; i != e; ++i) {
 459     switch (Args[i].getKind()) {
 460     case TemplateArgument::Null:
 461       llvm_unreachable("Impossible TemplateArgument");
 462
 463     case TemplateArgument::Integral:
 464     case TemplateArgument::Declaration:
 465     case TemplateArgument::NullPtr:
 466       ArgInfos[i] = TemplateArgumentLocInfo();
 467       break;
 468
 469     case TemplateArgument::Expression:
 470       ArgInfos[i] = TemplateArgumentLocInfo(Args[i].getAsExpr());
 471       break;
 472
 473     case TemplateArgument::Type:
 474       ArgInfos[i] = TemplateArgumentLocInfo(
 475                           Context.getTrivialTypeSourceInfo(Args[i].getAsType(),
 476                                                            Loc));
 477       break;
 478
 479     case TemplateArgument::Template:
 480     case TemplateArgument::TemplateExpansion: {
 481       NestedNameSpecifierLocBuilder Builder;
 482       TemplateName Template = Args[i].getAsTemplateOrTemplatePattern();
 483       if (DependentTemplateName *DTN = Template.getAsDependentTemplateName())
 484         Builder.MakeTrivial(Context, DTN->getQualifier(), Loc);
 485       else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
 486         Builder.MakeTrivial(Context, QTN->getQualifier(), Loc);
 487
 488       ArgInfos[i] = TemplateArgumentLocInfo(
 489           Builder.getWithLocInContext(Context), Loc,
 490           Args[i].getKind() == TemplateArgument::Template ? SourceLocation()
 491                                                           : Loc);
 492       break;
 493     }
 494
 495     case TemplateArgument::Pack:
 496       ArgInfos[i] = TemplateArgumentLocInfo();
 497       break;
 498     }
 499   }
 500 }