Lines Matching defs:E
443 void ASTStmtWriter::VisitCoroutineSuspendExpr(CoroutineSuspendExpr *E) {
444 VisitExpr(E);
445 Record.AddSourceLocation(E->getKeywordLoc());
446 for (Stmt *S : E->children())
448 Record.AddStmt(E->getOpaqueValue());
451 void ASTStmtWriter::VisitCoawaitExpr(CoawaitExpr *E) {
452 VisitCoroutineSuspendExpr(E);
453 Record.push_back(E->isImplicit());
457 void ASTStmtWriter::VisitCoyieldExpr(CoyieldExpr *E) {
458 VisitCoroutineSuspendExpr(E);
462 void ASTStmtWriter::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) {
463 VisitExpr(E);
464 Record.AddSourceLocation(E->getKeywordLoc());
465 for (Stmt *S : E->children())
478 auto *E = dyn_cast<Expr *>(DetailRecord);
479 Record.push_back(/* IsDiagnostic */ E == nullptr);
480 if (E)
481 Record.AddStmt(E);
501 ConceptSpecializationExpr *E) {
502 VisitExpr(E);
503 Record.AddDeclRef(E->getSpecializationDecl());
504 const ConceptReference *CR = E->getConceptReference();
508 if (!E->isValueDependent())
509 addConstraintSatisfaction(Record, E->getSatisfaction());
514 void ASTStmtWriter::VisitRequiresExpr(RequiresExpr *E) {
515 VisitExpr(E);
516 Record.push_back(E->getLocalParameters().size());
517 Record.push_back(E->getRequirements().size());
518 Record.AddSourceLocation(E->RequiresExprBits.RequiresKWLoc);
519 Record.push_back(E->RequiresExprBits.IsSatisfied);
520 Record.AddDeclRef(E->getBody());
521 for (ParmVarDecl *P : E->getLocalParameters())
523 for (concepts::Requirement *R : E->getRequirements()) {
573 Record.AddSourceLocation(E->getLParenLoc());
574 Record.AddSourceLocation(E->getRParenLoc());
575 Record.AddSourceLocation(E->getEndLoc());
620 void ASTStmtWriter::VisitExpr(Expr *E) {
621 VisitStmt(E);
624 CurrentPackingBits.addBits(E->getDependence(), /*BitsWidth=*/5);
625 CurrentPackingBits.addBits(E->getValueKind(), /*BitsWidth=*/2);
626 CurrentPackingBits.addBits(E->getObjectKind(), /*BitsWidth=*/3);
628 Record.AddTypeRef(E->getType());
631 void ASTStmtWriter::VisitConstantExpr(ConstantExpr *E) {
632 VisitExpr(E);
633 Record.push_back(E->ConstantExprBits.ResultKind);
635 Record.push_back(E->ConstantExprBits.APValueKind);
636 Record.push_back(E->ConstantExprBits.IsUnsigned);
637 Record.push_back(E->ConstantExprBits.BitWidth);
639 Record.push_back(E->ConstantExprBits.IsImmediateInvocation);
641 switch (E->getResultStorageKind()) {
645 Record.push_back(E->Int64Result());
648 Record.AddAPValue(E->APValueResult());
652 Record.AddStmt(E->getSubExpr());
656 void ASTStmtWriter::VisitOpenACCAsteriskSizeExpr(OpenACCAsteriskSizeExpr *E) {
657 VisitExpr(E);
658 Record.AddSourceLocation(E->getLocation());
662 void ASTStmtWriter::VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E) {
663 VisitExpr(E);
665 Record.AddSourceLocation(E->getLocation());
666 Record.AddSourceLocation(E->getLParenLocation());
667 Record.AddSourceLocation(E->getRParenLocation());
668 Record.AddTypeSourceInfo(E->getTypeSourceInfo());
673 void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) {
674 VisitExpr(E);
676 bool HasFunctionName = E->getFunctionName() != nullptr;
679 llvm::to_underlying(E->getIdentKind())); // FIXME: stable encoding
680 Record.push_back(E->isTransparent());
681 Record.AddSourceLocation(E->getLocation());
683 Record.AddStmt(E->getFunctionName());
687 void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) {
688 VisitExpr(E);
692 CurrentPackingBits.addBit(E->hadMultipleCandidates());
693 CurrentPackingBits.addBit(E->refersToEnclosingVariableOrCapture());
694 CurrentPackingBits.addBits(E->isNonOdrUse(), /*Width=*/2);
695 CurrentPackingBits.addBit(E->isImmediateEscalating());
696 CurrentPackingBits.addBit(E->getDecl() != E->getFoundDecl());
697 CurrentPackingBits.addBit(E->hasQualifier());
698 CurrentPackingBits.addBit(E->hasTemplateKWAndArgsInfo());
700 if (E->hasTemplateKWAndArgsInfo()) {
701 unsigned NumTemplateArgs = E->getNumTemplateArgs();
705 DeclarationName::NameKind nk = (E->getDecl()->getDeclName().getNameKind());
707 if ((!E->hasTemplateKWAndArgsInfo()) && (!E->hasQualifier()) &&
708 (E->getDecl() == E->getFoundDecl()) &&
709 nk == DeclarationName::Identifier && E->getObjectKind() == OK_Ordinary) {
713 if (E->hasQualifier())
714 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
716 if (E->getDecl() != E->getFoundDecl())
717 Record.AddDeclRef(E->getFoundDecl());
719 if (E->hasTemplateKWAndArgsInfo())
720 AddTemplateKWAndArgsInfo(*E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
721 E->getTrailingObjects<TemplateArgumentLoc>());
723 Record.AddDeclRef(E->getDecl());
724 Record.AddSourceLocation(E->getLocation());
725 Record.AddDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName());
729 void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) {
730 VisitExpr(E);
731 Record.AddSourceLocation(E->getLocation());
732 Record.AddAPInt(E->getValue());
734 if (E->getValue().getBitWidth() == 32) {
741 void ASTStmtWriter::VisitFixedPointLiteral(FixedPointLiteral *E) {
742 VisitExpr(E);
743 Record.AddSourceLocation(E->getLocation());
744 Record.push_back(E->getScale());
745 Record.AddAPInt(E->getValue());
749 void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) {
750 VisitExpr(E);
751 Record.push_back(E->getRawSemantics());
752 Record.push_back(E->isExact());
753 Record.AddAPFloat(E->getValue());
754 Record.AddSourceLocation(E->getLocation());
758 void ASTStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
759 VisitExpr(E);
760 Record.AddStmt(E->getSubExpr());
764 void ASTStmtWriter::VisitStringLiteral(StringLiteral *E) {
765 VisitExpr(E);
768 Record.push_back(E->getNumConcatenated());
769 Record.push_back(E->getLength());
770 Record.push_back(E->getCharByteWidth());
771 Record.push_back(llvm::to_underlying(E->getKind()));
772 Record.push_back(E->isPascal());
775 for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
776 Record.AddSourceLocation(E->getStrTokenLoc(I));
779 StringRef StrData = E->getBytes();
780 for (unsigned I = 0, N = E->getByteLength(); I != N; ++I)
786 void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) {
787 VisitExpr(E);
788 Record.push_back(E->getValue());
789 Record.AddSourceLocation(E->getLocation());
790 Record.push_back(llvm::to_underlying(E->getKind()));
797 void ASTStmtWriter::VisitParenExpr(ParenExpr *E) {
798 VisitExpr(E);
799 Record.push_back(E->isProducedByFoldExpansion());
800 Record.AddSourceLocation(E->getLParen());
801 Record.AddSourceLocation(E->getRParen());
802 Record.AddStmt(E->getSubExpr());
806 void ASTStmtWriter::VisitParenListExpr(ParenListExpr *E) {
807 VisitExpr(E);
808 Record.push_back(E->getNumExprs());
809 for (auto *SubStmt : E->exprs())
811 Record.AddSourceLocation(E->getLParenLoc());
812 Record.AddSourceLocation(E->getRParenLoc());
816 void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) {
817 VisitExpr(E);
818 bool HasFPFeatures = E->hasStoredFPFeatures();
822 Record.AddStmt(E->getSubExpr());
823 CurrentPackingBits.addBits(E->getOpcode(),
825 Record.AddSourceLocation(E->getOperatorLoc());
826 CurrentPackingBits.addBit(E->canOverflow());
829 Record.push_back(E->getStoredFPFeatures().getAsOpaqueInt());
833 void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) {
834 VisitExpr(E);
835 Record.push_back(E->getNumComponents());
836 Record.push_back(E->getNumExpressions());
837 Record.AddSourceLocation(E->getOperatorLoc());
838 Record.AddSourceLocation(E->getRParenLoc());
839 Record.AddTypeSourceInfo(E->getTypeSourceInfo());
840 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
841 const OffsetOfNode &ON = E->getComponent(I);
863 for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
864 Record.AddStmt(E->getIndexExpr(I));
868 void ASTStmtWriter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
869 VisitExpr(E);
870 Record.push_back(E->getKind());
871 if (E->isArgumentType())
872 Record.AddTypeSourceInfo(E->getArgumentTypeInfo());
875 Record.AddStmt(E->getArgumentExpr());
877 Record.AddSourceLocation(E->getOperatorLoc());
878 Record.AddSourceLocation(E->getRParenLoc());
882 void ASTStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
883 VisitExpr(E);
884 Record.AddStmt(E->getLHS());
885 Record.AddStmt(E->getRHS());
886 Record.AddSourceLocation(E->getRBracketLoc());
890 void ASTStmtWriter::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E) {
891 VisitExpr(E);
892 Record.AddStmt(E->getBase());
893 Record.AddStmt(E->getRowIdx());
894 Record.AddStmt(E->getColumnIdx());
895 Record.AddSourceLocation(E->getRBracketLoc());
899 void ASTStmtWriter::VisitArraySectionExpr(ArraySectionExpr *E) {
900 VisitExpr(E);
901 Record.writeEnum(E->ASType);
902 Record.AddStmt(E->getBase());
903 Record.AddStmt(E->getLowerBound());
904 Record.AddStmt(E->getLength());
905 if (E->isOMPArraySection())
906 Record.AddStmt(E->getStride());
907 Record.AddSourceLocation(E->getColonLocFirst());
909 if (E->isOMPArraySection())
910 Record.AddSourceLocation(E->getColonLocSecond());
912 Record.AddSourceLocation(E->getRBracketLoc());
916 void ASTStmtWriter::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *E) {
917 VisitExpr(E);
918 Record.push_back(E->getDimensions().size());
919 Record.AddStmt(E->getBase());
920 for (Expr *Dim : E->getDimensions())
922 for (SourceRange SR : E->getBracketsRanges())
924 Record.AddSourceLocation(E->getLParenLoc());
925 Record.AddSourceLocation(E->getRParenLoc());
929 void ASTStmtWriter::VisitOMPIteratorExpr(OMPIteratorExpr *E) {
930 VisitExpr(E);
931 Record.push_back(E->numOfIterators());
932 Record.AddSourceLocation(E->getIteratorKwLoc());
933 Record.AddSourceLocation(E->getLParenLoc());
934 Record.AddSourceLocation(E->getRParenLoc());
935 for (unsigned I = 0, End = E->numOfIterators(); I < End; ++I) {
936 Record.AddDeclRef(E->getIteratorDecl(I));
937 Record.AddSourceLocation(E->getAssignLoc(I));
938 OMPIteratorExpr::IteratorRange Range = E->getIteratorRange(I);
942 Record.AddSourceLocation(E->getColonLoc(I));
944 Record.AddSourceLocation(E->getSecondColonLoc(I));
946 OMPIteratorHelperData &HD = E->getHelper(I);
955 void ASTStmtWriter::VisitCallExpr(CallExpr *E) {
956 VisitExpr(E);
958 Record.push_back(E->getNumArgs());
960 CurrentPackingBits.addBit(static_cast<bool>(E->getADLCallKind()));
961 CurrentPackingBits.addBit(E->hasStoredFPFeatures());
963 Record.AddSourceLocation(E->getRParenLoc());
964 Record.AddStmt(E->getCallee());
965 for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
969 if (E->hasStoredFPFeatures())
970 Record.push_back(E->getFPFeatures().getAsOpaqueInt());
972 if (!E->hasStoredFPFeatures() && !static_cast<bool>(E->getADLCallKind()) &&
973 E->getStmtClass() == Stmt::CallExprClass)
979 void ASTStmtWriter::VisitRecoveryExpr(RecoveryExpr *E) {
980 VisitExpr(E);
981 Record.push_back(std::distance(E->children().begin(), E->children().end()));
982 Record.AddSourceLocation(E->getBeginLoc());
983 Record.AddSourceLocation(E->getEndLoc());
984 for (Stmt *Child : E->children())
989 void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) {
990 VisitExpr(E);
992 bool HasQualifier = E->hasQualifier();
993 bool HasFoundDecl = E->hasFoundDecl();
994 bool HasTemplateInfo = E->hasTemplateKWAndArgsInfo();
995 unsigned NumTemplateArgs = E->getNumTemplateArgs();
1005 Record.AddStmt(E->getBase());
1006 Record.AddDeclRef(E->getMemberDecl());
1007 Record.AddDeclarationNameLoc(E->MemberDNLoc,
1008 E->getMemberDecl()->getDeclName());
1009 Record.AddSourceLocation(E->getMemberLoc());
1010 CurrentPackingBits.addBit(E->isArrow());
1011 CurrentPackingBits.addBit(E->hadMultipleCandidates());
1012 CurrentPackingBits.addBits(E->isNonOdrUse(), /*Width=*/2);
1013 Record.AddSourceLocation(E->getOperatorLoc());
1016 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
1019 DeclAccessPair FoundDecl = E->getFoundDecl();
1025 AddTemplateKWAndArgsInfo(*E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1026 E->getTrailingObjects<TemplateArgumentLoc>());
1031 void ASTStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) {
1032 VisitExpr(E);
1033 Record.AddStmt(E->getBase());
1034 Record.AddSourceLocation(E->getIsaMemberLoc());
1035 Record.AddSourceLocation(E->getOpLoc());
1036 Record.push_back(E->isArrow());
1041 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
1042 VisitExpr(E);
1043 Record.AddStmt(E->getSubExpr());
1044 Record.push_back(E->shouldCopy());
1048 void ASTStmtWriter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
1049 VisitExplicitCastExpr(E);
1050 Record.AddSourceLocation(E->getLParenLoc());
1051 Record.AddSourceLocation(E->getBridgeKeywordLoc());
1052 Record.push_back(E->getBridgeKind()); // FIXME: Stable encoding
1056 void ASTStmtWriter::VisitCastExpr(CastExpr *E) {
1057 VisitExpr(E);
1059 Record.push_back(E->path_size());
1062 CurrentPackingBits.addBits(E->getCastKind(), /*Width=*/7);
1063 CurrentPackingBits.addBit(E->hasStoredFPFeatures());
1064 Record.AddStmt(E->getSubExpr());
1067 PI = E->path_begin(), PE = E->path_end(); PI != PE; ++PI)
1070 if (E->hasStoredFPFeatures())
1071 Record.push_back(E->getFPFeatures().getAsOpaqueInt());
1074 void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) {
1075 VisitExpr(E);
1080 CurrentPackingBits.addBits(E->getOpcode(), /*Width=*/6);
1081 bool HasFPFeatures = E->hasStoredFPFeatures();
1083 CurrentPackingBits.addBit(E->hasExcludedOverflowPattern());
1084 Record.AddStmt(E->getLHS());
1085 Record.AddStmt(E->getRHS());
1086 Record.AddSourceLocation(E->getOperatorLoc());
1088 Record.push_back(E->getStoredFPFeatures().getAsOpaqueInt());
1090 if (!HasFPFeatures && E->getValueKind() == VK_PRValue &&
1091 E->getObjectKind() == OK_Ordinary)
1097 void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
1098 VisitBinaryOperator(E);
1099 Record.AddTypeRef(E->getComputationLHSType());
1100 Record.AddTypeRef(E->getComputationResultType());
1102 if (!E->hasStoredFPFeatures() && E->getValueKind() == VK_PRValue &&
1103 E->getObjectKind() == OK_Ordinary)
1109 void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator *E) {
1110 VisitExpr(E);
1111 Record.AddStmt(E->getCond());
1112 Record.AddStmt(E->getLHS());
1113 Record.AddStmt(E->getRHS());
1114 Record.AddSourceLocation(E->getQuestionLoc());
1115 Record.AddSourceLocation(E->getColonLoc());
1120 ASTStmtWriter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
1121 VisitExpr(E);
1122 Record.AddStmt(E->getOpaqueValue());
1123 Record.AddStmt(E->getCommon());
1124 Record.AddStmt(E->getCond());
1125 Record.AddStmt(E->getTrueExpr());
1126 Record.AddStmt(E->getFalseExpr());
1127 Record.AddSourceLocation(E->getQuestionLoc());
1128 Record.AddSourceLocation(E->getColonLoc());
1132 void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
1133 VisitCastExpr(E);
1134 CurrentPackingBits.addBit(E->isPartOfExplicitCast());
1136 if (E->path_size() == 0 && !E->hasStoredFPFeatures())
1142 void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
1143 VisitCastExpr(E);
1144 Record.AddTypeSourceInfo(E->getTypeInfoAsWritten());
1147 void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) {
1148 VisitExplicitCastExpr(E);
1149 Record.AddSourceLocation(E->getLParenLoc());
1150 Record.AddSourceLocation(E->getRParenLoc());
1154 void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
1155 VisitExpr(E);
1156 Record.AddSourceLocation(E->getLParenLoc());
1157 Record.AddTypeSourceInfo(E->getTypeSourceInfo());
1158 Record.AddStmt(E->getInitializer());
1159 Record.push_back(E->isFileScope());
1163 void ASTStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
1164 VisitExpr(E);
1165 Record.AddStmt(E->getBase());
1166 Record.AddIdentifierRef(&E->getAccessor());
1167 Record.AddSourceLocation(E->getAccessorLoc());
1171 void ASTStmtWriter::VisitInitListExpr(InitListExpr *E) {
1172 VisitExpr(E);
1175 Record.AddStmt(E->getSyntacticForm());
1176 Record.AddSourceLocation(E->getLBraceLoc());
1177 Record.AddSourceLocation(E->getRBraceLoc());
1178 bool isArrayFiller = isa<Expr *>(E->ArrayFillerOrUnionFieldInit);
1181 Record.AddStmt(E->getArrayFiller());
1183 Record.AddDeclRef(E->getInitializedFieldInUnion());
1184 Record.push_back(E->hadArrayRangeDesignator());
1185 Record.push_back(E->getNumInits());
1189 Expr *filler = E->getArrayFiller();
1190 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
1191 Record.AddStmt(E->getInit(I) != filler ? E->getInit(I) : nullptr);
1193 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
1194 Record.AddStmt(E->getInit(I));
1199 void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
1200 VisitExpr(E);
1201 Record.push_back(E->getNumSubExprs());
1202 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
1203 Record.AddStmt(E->getSubExpr(I));
1204 Record.AddSourceLocation(E->getEqualOrColonLoc());
1205 Record.push_back(E->usesGNUSyntax());
1206 for (const DesignatedInitExpr::Designator &D : E->designators()) {
1234 void ASTStmtWriter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
1235 VisitExpr(E);
1236 Record.AddStmt(E->getBase());
1237 Record.AddStmt(E->getUpdater());
1241 void ASTStmtWriter::VisitNoInitExpr(NoInitExpr *E) {
1242 VisitExpr(E);
1246 void ASTStmtWriter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
1247 VisitExpr(E);
1248 Record.AddStmt(E->SubExprs[0]);
1249 Record.AddStmt(E->SubExprs[1]);
1253 void ASTStmtWriter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
1254 VisitExpr(E);
1258 void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
1259 VisitExpr(E);
1263 void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) {
1264 VisitExpr(E);
1265 Record.AddStmt(E->getSubExpr());
1266 Record.AddTypeSourceInfo(E->getWrittenTypeInfo());
1267 Record.AddSourceLocation(E->getBuiltinLoc());
1268 Record.AddSourceLocation(E->getRParenLoc());
1269 Record.push_back(E->isMicrosoftABI());
1273 void ASTStmtWriter::VisitSourceLocExpr(SourceLocExpr *E) {
1274 VisitExpr(E);
1275 Record.AddDeclRef(cast_or_null<Decl>(E->getParentContext()));
1276 Record.AddSourceLocation(E->getBeginLoc());
1277 Record.AddSourceLocation(E->getEndLoc());
1278 Record.push_back(llvm::to_underlying(E->getIdentKind()));
1282 void ASTStmtWriter::VisitEmbedExpr(EmbedExpr *E) {
1283 VisitExpr(E);
1284 Record.AddSourceLocation(E->getBeginLoc());
1285 Record.AddSourceLocation(E->getEndLoc());
1286 Record.AddStmt(E->getDataStringLiteral());
1287 Record.writeUInt32(E->getStartingElementPos());
1288 Record.writeUInt32(E->getDataElementCount());
1292 void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) {
1293 VisitExpr(E);
1294 Record.AddSourceLocation(E->getAmpAmpLoc());
1295 Record.AddSourceLocation(E->getLabelLoc());
1296 Record.AddDeclRef(E->getLabel());
1300 void ASTStmtWriter::VisitStmtExpr(StmtExpr *E) {
1301 VisitExpr(E);
1302 Record.AddStmt(E->getSubStmt());
1303 Record.AddSourceLocation(E->getLParenLoc());
1304 Record.AddSourceLocation(E->getRParenLoc());
1305 Record.push_back(E->getTemplateDepth());
1309 void ASTStmtWriter::VisitChooseExpr(ChooseExpr *E) {
1310 VisitExpr(E);
1311 Record.AddStmt(E->getCond());
1312 Record.AddStmt(E->getLHS());
1313 Record.AddStmt(E->getRHS());
1314 Record.AddSourceLocation(E->getBuiltinLoc());
1315 Record.AddSourceLocation(E->getRParenLoc());
1316 Record.push_back(E->isConditionDependent() ? false : E->isConditionTrue());
1320 void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) {
1321 VisitExpr(E);
1322 Record.AddSourceLocation(E->getTokenLocation());
1326 void ASTStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
1327 VisitExpr(E);
1328 Record.push_back(E->getNumSubExprs());
1329 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
1330 Record.AddStmt(E->getExpr(I));
1331 Record.AddSourceLocation(E->getBuiltinLoc());
1332 Record.AddSourceLocation(E->getRParenLoc());
1336 void ASTStmtWriter::VisitConvertVectorExpr(ConvertVectorExpr *E) {
1337 VisitExpr(E);
1338 Record.AddSourceLocation(E->getBuiltinLoc());
1339 Record.AddSourceLocation(E->getRParenLoc());
1340 Record.AddTypeSourceInfo(E->getTypeSourceInfo());
1341 Record.AddStmt(E->getSrcExpr());
1345 void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) {
1346 VisitExpr(E);
1347 Record.AddDeclRef(E->getBlockDecl());
1351 void ASTStmtWriter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
1352 VisitExpr(E);
1354 Record.push_back(E->getNumAssocs());
1355 Record.push_back(E->isExprPredicate());
1356 Record.push_back(E->ResultIndex);
1357 Record.AddSourceLocation(E->getGenericLoc());
1358 Record.AddSourceLocation(E->getDefaultLoc());
1359 Record.AddSourceLocation(E->getRParenLoc());
1361 Stmt **Stmts = E->getTrailingObjects<Stmt *>();
1365 for (unsigned I = 0, N = E->getNumAssocs() + 1; I < N; ++I)
1368 TypeSourceInfo **TSIs = E->getTrailingObjects<TypeSourceInfo *>();
1369 for (unsigned I = 0, N = E->getNumAssocs(); I < N; ++I)
1375 void ASTStmtWriter::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
1376 VisitExpr(E);
1377 Record.push_back(E->getNumSemanticExprs());
1381 unsigned result = E->getResultExprIndex();
1385 Record.AddStmt(E->getSyntacticForm());
1387 i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) {
1393 void ASTStmtWriter::VisitAtomicExpr(AtomicExpr *E) {
1394 VisitExpr(E);
1395 Record.push_back(E->getOp());
1396 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
1397 Record.AddStmt(E->getSubExprs()[I]);
1398 Record.AddSourceLocation(E->getBuiltinLoc());
1399 Record.AddSourceLocation(E->getRParenLoc());
1407 void ASTStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) {
1408 VisitExpr(E);
1409 Record.AddStmt(E->getString());
1410 Record.AddSourceLocation(E->getAtLoc());
1414 void ASTStmtWriter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
1415 VisitExpr(E);
1416 Record.AddStmt(E->getSubExpr());
1417 Record.AddDeclRef(E->getBoxingMethod());
1418 Record.AddSourceRange(E->getSourceRange());
1422 void ASTStmtWriter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
1423 VisitExpr(E);
1424 Record.push_back(E->getNumElements());
1425 for (unsigned i = 0; i < E->getNumElements(); i++)
1426 Record.AddStmt(E->getElement(i));
1427 Record.AddDeclRef(E->getArrayWithObjectsMethod());
1428 Record.AddSourceRange(E->getSourceRange());
1432 void ASTStmtWriter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
1433 VisitExpr(E);
1434 Record.push_back(E->getNumElements());
1435 Record.push_back(E->HasPackExpansions);
1436 for (unsigned i = 0; i < E->getNumElements(); i++) {
1437 ObjCDictionaryElement Element = E->getKeyValueElement(i);
1440 if (E->HasPackExpansions) {
1449 Record.AddDeclRef(E->getDictWithObjectsMethod());
1450 Record.AddSourceRange(E->getSourceRange());
1454 void ASTStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
1455 VisitExpr(E);
1456 Record.AddTypeSourceInfo(E->getEncodedTypeSourceInfo());
1457 Record.AddSourceLocation(E->getAtLoc());
1458 Record.AddSourceLocation(E->getRParenLoc());
1462 void ASTStmtWriter::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
1463 VisitExpr(E);
1464 Record.AddSelectorRef(E->getSelector());
1465 Record.AddSourceLocation(E->getAtLoc());
1466 Record.AddSourceLocation(E->getRParenLoc());
1470 void ASTStmtWriter::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
1471 VisitExpr(E);
1472 Record.AddDeclRef(E->getProtocol());
1473 Record.AddSourceLocation(E->getAtLoc());
1474 Record.AddSourceLocation(E->ProtoLoc);
1475 Record.AddSourceLocation(E->getRParenLoc());
1479 void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
1480 VisitExpr(E);
1481 Record.AddDeclRef(E->getDecl());
1482 Record.AddSourceLocation(E->getLocation());
1483 Record.AddSourceLocation(E->getOpLoc());
1484 Record.AddStmt(E->getBase());
1485 Record.push_back(E->isArrow());
1486 Record.push_back(E->isFreeIvar());
1490 void ASTStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
1491 VisitExpr(E);
1492 Record.push_back(E->SetterAndMethodRefFlags.getInt());
1493 Record.push_back(E->isImplicitProperty());
1494 if (E->isImplicitProperty()) {
1495 Record.AddDeclRef(E->getImplicitPropertyGetter());
1496 Record.AddDeclRef(E->getImplicitPropertySetter());
1498 Record.AddDeclRef(E->getExplicitProperty());
1500 Record.AddSourceLocation(E->getLocation());
1501 Record.AddSourceLocation(E->getReceiverLocation());
1502 if (E->isObjectReceiver()) {
1504 Record.AddStmt(E->getBase());
1505 } else if (E->isSuperReceiver()) {
1507 Record.AddTypeRef(E->getSuperReceiverType());
1510 Record.AddDeclRef(E->getClassReceiver());
1516 void ASTStmtWriter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1517 VisitExpr(E);
1518 Record.AddSourceLocation(E->getRBracket());
1519 Record.AddStmt(E->getBaseExpr());
1520 Record.AddStmt(E->getKeyExpr());
1521 Record.AddDeclRef(E->getAtIndexMethodDecl());
1522 Record.AddDeclRef(E->setAtIndexMethodDecl());
1527 void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1528 VisitExpr(E);
1529 Record.push_back(E->getNumArgs());
1530 Record.push_back(E->getNumStoredSelLocs());
1531 Record.push_back(E->SelLocsKind);
1532 Record.push_back(E->isDelegateInitCall());
1533 Record.push_back(E->IsImplicit);
1534 Record.push_back((unsigned)E->getReceiverKind()); // FIXME: stable encoding
1535 switch (E->getReceiverKind()) {
1537 Record.AddStmt(E->getInstanceReceiver());
1541 Record.AddTypeSourceInfo(E->getClassReceiverTypeInfo());
1546 Record.AddTypeRef(E->getSuperType());
1547 Record.AddSourceLocation(E->getSuperLoc());
1551 if (E->getMethodDecl()) {
1553 Record.AddDeclRef(E->getMethodDecl());
1556 Record.AddSelectorRef(E->getSelector());
1559 Record.AddSourceLocation(E->getLeftLoc());
1560 Record.AddSourceLocation(E->getRightLoc());
1562 for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
1566 SourceLocation *Locs = E->getStoredSelLocs();
1567 for (unsigned i = 0, e = E->getNumStoredSelLocs(); i != e; ++i)
1634 void ASTStmtWriter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1635 VisitExpr(E);
1636 Record.push_back(E->getValue());
1637 Record.AddSourceLocation(E->getLocation());
1641 void ASTStmtWriter::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
1642 VisitExpr(E);
1643 Record.AddSourceRange(E->getSourceRange());
1644 Record.AddVersionTuple(E->getVersion());
1697 void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1698 VisitCallExpr(E);
1699 Record.push_back(E->getOperator());
1700 Record.AddSourceRange(E->Range);
1702 if (!E->hasStoredFPFeatures() && !static_cast<bool>(E->getADLCallKind()))
1708 void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
1709 VisitCallExpr(E);
1711 if (!E->hasStoredFPFeatures() && !static_cast<bool>(E->getADLCallKind()))
1718 CXXRewrittenBinaryOperator *E) {
1719 VisitExpr(E);
1720 Record.push_back(E->isReversed());
1721 Record.AddStmt(E->getSemanticForm());
1725 void ASTStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) {
1726 VisitExpr(E);
1728 Record.push_back(E->getNumArgs());
1729 Record.push_back(E->isElidable());
1730 Record.push_back(E->hadMultipleCandidates());
1731 Record.push_back(E->isListInitialization());
1732 Record.push_back(E->isStdInitListInitialization());
1733 Record.push_back(E->requiresZeroInitialization());
1735 llvm::to_underlying(E->getConstructionKind())); // FIXME: stable encoding
1736 Record.push_back(E->isImmediateEscalating());
1737 Record.AddSourceLocation(E->getLocation());
1738 Record.AddDeclRef(E->getConstructor());
1739 Record.AddSourceRange(E->getParenOrBraceRange());
1741 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1742 Record.AddStmt(E->getArg(I));
1747 void ASTStmtWriter::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
1748 VisitExpr(E);
1749 Record.AddDeclRef(E->getConstructor());
1750 Record.AddSourceLocation(E->getLocation());
1751 Record.push_back(E->constructsVBase());
1752 Record.push_back(E->inheritedFromVBase());
1756 void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1757 VisitCXXConstructExpr(E);
1758 Record.AddTypeSourceInfo(E->getTypeSourceInfo());
1762 void ASTStmtWriter::VisitLambdaExpr(LambdaExpr *E) {
1763 VisitExpr(E);
1764 Record.push_back(E->LambdaExprBits.NumCaptures);
1765 Record.AddSourceRange(E->IntroducerRange);
1766 Record.push_back(E->LambdaExprBits.CaptureDefault); // FIXME: stable encoding
1767 Record.AddSourceLocation(E->CaptureDefaultLoc);
1768 Record.push_back(E->LambdaExprBits.ExplicitParams);
1769 Record.push_back(E->LambdaExprBits.ExplicitResultType);
1770 Record.AddSourceLocation(E->ClosingBrace);
1773 for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
1774 CEnd = E->capture_init_end();
1785 void ASTStmtWriter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1786 VisitExpr(E);
1787 Record.AddStmt(E->getSubExpr());
1791 void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1792 VisitExplicitCastExpr(E);
1793 Record.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc()));
1794 CurrentPackingBits.addBit(E->getAngleBrackets().isValid());
1795 if (E->getAngleBrackets().isValid())
1796 Record.AddSourceRange(E->getAngleBrackets());
1799 void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1800 VisitCXXNamedCastExpr(E);
1804 void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1805 VisitCXXNamedCastExpr(E);
1809 void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1810 VisitCXXNamedCastExpr(E);
1814 void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1815 VisitCXXNamedCastExpr(E);
1819 void ASTStmtWriter::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) {
1820 VisitCXXNamedCastExpr(E);
1824 void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1825 VisitExplicitCastExpr(E);
1826 Record.AddSourceLocation(E->getLParenLoc());
1827 Record.AddSourceLocation(E->getRParenLoc());
1831 void ASTStmtWriter::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) {
1832 VisitExplicitCastExpr(E);
1833 Record.AddSourceLocation(E->getBeginLoc());
1834 Record.AddSourceLocation(E->getEndLoc());
1838 void ASTStmtWriter::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1839 VisitCallExpr(E);
1840 Record.AddSourceLocation(E->UDSuffixLoc);
1844 void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1845 VisitExpr(E);
1846 Record.push_back(E->getValue());
1847 Record.AddSourceLocation(E->getLocation());
1851 void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1852 VisitExpr(E);
1853 Record.AddSourceLocation(E->getLocation());
1857 void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1858 VisitExpr(E);
1859 Record.AddSourceRange(E->getSourceRange());
1860 if (E->isTypeOperand()) {
1861 Record.AddTypeSourceInfo(E->getTypeOperandSourceInfo());
1864 Record.AddStmt(E->getExprOperand());
1869 void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) {
1870 VisitExpr(E);
1871 Record.AddSourceLocation(E->getLocation());
1872 Record.push_back(E->isImplicit());
1873 Record.push_back(E->isCapturedByCopyInLambdaWithExplicitObjectParameter());
1878 void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) {
1879 VisitExpr(E);
1880 Record.AddSourceLocation(E->getThrowLoc());
1881 Record.AddStmt(E->getSubExpr());
1882 Record.push_back(E->isThrownVariableInScope());
1886 void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1887 VisitExpr(E);
1888 Record.AddDeclRef(E->getParam());
1889 Record.AddDeclRef(cast_or_null<Decl>(E->getUsedContext()));
1890 Record.AddSourceLocation(E->getUsedLocation());
1891 Record.push_back(E->hasRewrittenInit());
1892 if (E->hasRewrittenInit())
1893 Record.AddStmt(E->getRewrittenExpr());
1897 void ASTStmtWriter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1898 VisitExpr(E);
1899 Record.push_back(E->hasRewrittenInit());
1900 Record.AddDeclRef(E->getField());
1901 Record.AddDeclRef(cast_or_null<Decl>(E->getUsedContext()));
1902 Record.AddSourceLocation(E->getExprLoc());
1903 if (E->hasRewrittenInit())
1904 Record.AddStmt(E->getRewrittenExpr());
1908 void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1909 VisitExpr(E);
1910 Record.AddCXXTemporary(E->getTemporary());
1911 Record.AddStmt(E->getSubExpr());
1915 void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1916 VisitExpr(E);
1917 Record.AddTypeSourceInfo(E->getTypeSourceInfo());
1918 Record.AddSourceLocation(E->getRParenLoc());
1922 void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) {
1923 VisitExpr(E);
1925 Record.push_back(E->isArray());
1926 Record.push_back(E->hasInitializer());
1927 Record.push_back(E->getNumPlacementArgs());
1928 Record.push_back(E->isParenTypeId());
1930 Record.push_back(E->isGlobalNew());
1931 Record.push_back(E->passAlignment());
1932 Record.push_back(E->doesUsualArrayDeleteWantSize());
1933 Record.push_back(E->CXXNewExprBits.HasInitializer);
1934 Record.push_back(E->CXXNewExprBits.StoredInitializationStyle);
1936 Record.AddDeclRef(E->getOperatorNew());
1937 Record.AddDeclRef(E->getOperatorDelete());
1938 Record.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo());
1939 if (E->isParenTypeId())
1940 Record.AddSourceRange(E->getTypeIdParens());
1941 Record.AddSourceRange(E->getSourceRange());
1942 Record.AddSourceRange(E->getDirectInitRange());
1944 for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), N = E->raw_arg_end();
1951 void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1952 VisitExpr(E);
1953 Record.push_back(E->isGlobalDelete());
1954 Record.push_back(E->isArrayForm());
1955 Record.push_back(E->isArrayFormAsWritten());
1956 Record.push_back(E->doesUsualArrayDeleteWantSize());
1957 Record.AddDeclRef(E->getOperatorDelete());
1958 Record.AddStmt(E->getArgument());
1959 Record.AddSourceLocation(E->getBeginLoc());
1964 void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1965 VisitExpr(E);
1967 Record.AddStmt(E->getBase());
1968 Record.push_back(E->isArrow());
1969 Record.AddSourceLocation(E->getOperatorLoc());
1970 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
1971 Record.AddTypeSourceInfo(E->getScopeTypeInfo());
1972 Record.AddSourceLocation(E->getColonColonLoc());
1973 Record.AddSourceLocation(E->getTildeLoc());
1976 Record.AddIdentifierRef(E->getDestroyedTypeIdentifier());
1977 if (E->getDestroyedTypeIdentifier())
1978 Record.AddSourceLocation(E->getDestroyedTypeLoc());
1980 Record.AddTypeSourceInfo(E->getDestroyedTypeInfo());
1985 void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) {
1986 VisitExpr(E);
1987 Record.push_back(E->getNumObjects());
1988 for (auto &Obj : E->getObjects()) {
1998 Record.push_back(E->cleanupsHaveSideEffects());
1999 Record.AddStmt(E->getSubExpr());
2004 CXXDependentScopeMemberExpr *E) {
2005 VisitExpr(E);
2009 Record.push_back(E->getNumTemplateArgs());
2011 CurrentPackingBits.addBit(E->hasTemplateKWAndArgsInfo());
2012 CurrentPackingBits.addBit(E->hasFirstQualifierFoundInScope());
2014 if (E->hasTemplateKWAndArgsInfo()) {
2016 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
2018 E->getTrailingObjects<TemplateArgumentLoc>());
2021 CurrentPackingBits.addBit(E->isArrow());
2023 Record.AddTypeRef(E->getBaseType());
2024 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
2025 CurrentPackingBits.addBit(!E->isImplicitAccess());
2026 if (!E->isImplicitAccess())
2027 Record.AddStmt(E->getBase());
2029 Record.AddSourceLocation(E->getOperatorLoc());
2031 if (E->hasFirstQualifierFoundInScope())
2032 Record.AddDeclRef(E->getFirstQualifierFoundInScope());
2034 Record.AddDeclarationNameInfo(E->MemberNameInfo);
2039 ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
2040 VisitExpr(E);
2045 E->DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo);
2047 if (E->DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo) {
2049 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
2053 E->getTrailingObjects<TemplateArgumentLoc>());
2056 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
2057 Record.AddDeclarationNameInfo(E->NameInfo);
2062 ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
2063 VisitExpr(E);
2064 Record.push_back(E->getNumArgs());
2066 ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI)
2068 Record.AddTypeSourceInfo(E->getTypeSourceInfo());
2069 Record.AddSourceLocation(E->getLParenLoc());
2070 Record.AddSourceLocation(E->getRParenLoc());
2071 Record.push_back(E->isListInitialization());
2075 void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) {
2076 VisitExpr(E);
2078 Record.push_back(E->getNumDecls());
2081 CurrentPackingBits.addBit(E->hasTemplateKWAndArgsInfo());
2082 if (E->hasTemplateKWAndArgsInfo()) {
2084 *E->getTrailingASTTemplateKWAndArgsInfo();
2086 AddTemplateKWAndArgsInfo(ArgInfo, E->getTrailingTemplateArgumentLoc());
2089 for (OverloadExpr::decls_iterator OvI = E->decls_begin(),
2090 OvE = E->decls_end();
2096 Record.AddDeclarationNameInfo(E->getNameInfo());
2097 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
2100 void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
2101 VisitOverloadExpr(E);
2102 CurrentPackingBits.addBit(E->isArrow());
2103 CurrentPackingBits.addBit(E->hasUnresolvedUsing());
2104 CurrentPackingBits.addBit(!E->isImplicitAccess());
2105 if (!E->isImplicitAccess())
2106 Record.AddStmt(E->getBase());
2108 Record.AddSourceLocation(E->getOperatorLoc());
2110 Record.AddTypeRef(E->getBaseType());
2114 void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
2115 VisitOverloadExpr(E);
2116 CurrentPackingBits.addBit(E->requiresADL());
2117 Record.AddDeclRef(E->getNamingClass());
2123 DeclarationName Name = E->getName();
2137 void ASTStmtWriter::VisitTypeTraitExpr(TypeTraitExpr *E) {
2138 VisitExpr(E);
2139 Record.push_back(E->TypeTraitExprBits.NumArgs);
2140 Record.push_back(E->TypeTraitExprBits.Kind); // FIXME: Stable encoding
2141 Record.push_back(E->TypeTraitExprBits.Value);
2142 Record.AddSourceRange(E->getSourceRange());
2143 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
2144 Record.AddTypeSourceInfo(E->getArg(I));
2148 void ASTStmtWriter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
2149 VisitExpr(E);
2150 Record.push_back(E->getTrait());
2151 Record.push_back(E->getValue());
2152 Record.AddSourceRange(E->getSourceRange());
2153 Record.AddTypeSourceInfo(E->getQueriedTypeSourceInfo());
2154 Record.AddStmt(E->getDimensionExpression());
2158 void ASTStmtWriter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
2159 VisitExpr(E);
2160 Record.push_back(E->getTrait());
2161 Record.push_back(E->getValue());
2162 Record.AddSourceRange(E->getSourceRange());
2163 Record.AddStmt(E->getQueriedExpression());
2167 void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
2168 VisitExpr(E);
2169 Record.push_back(E->getValue());
2170 Record.AddSourceRange(E->getSourceRange());
2171 Record.AddStmt(E->getOperand());
2175 void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr *E) {
2176 VisitExpr(E);
2177 Record.AddSourceLocation(E->getEllipsisLoc());
2178 Record.push_back(E->NumExpansions);
2179 Record.AddStmt(E->getPattern());
2183 void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
2184 VisitExpr(E);
2185 Record.push_back(E->isPartiallySubstituted() ? E->getPartialArguments().size()
2187 Record.AddSourceLocation(E->OperatorLoc);
2188 Record.AddSourceLocation(E->PackLoc);
2189 Record.AddSourceLocation(E->RParenLoc);
2190 Record.AddDeclRef(E->Pack);
2191 if (E->isPartiallySubstituted()) {
2192 for (const auto &TA : E->getPartialArguments())
2194 } else if (!E->isValueDependent()) {
2195 Record.push_back(E->getPackLength());
2200 void ASTStmtWriter::VisitPackIndexingExpr(PackIndexingExpr *E) {
2201 VisitExpr(E);
2202 Record.push_back(E->TransformedExpressions);
2203 Record.push_back(E->FullySubstituted);
2204 Record.AddSourceLocation(E->getEllipsisLoc());
2205 Record.AddSourceLocation(E->getRSquareLoc());
2206 Record.AddStmt(E->getPackIdExpression());
2207 Record.AddStmt(E->getIndexExpr());
2208 for (Expr *Sub : E->getExpressions())
2214 ResolvedUnexpandedPackExpr *E) {
2215 VisitExpr(E);
2216 Record.push_back(E->getNumExprs());
2217 Record.AddSourceLocation(E->getBeginLoc());
2218 for (Expr *Sub : E->getExprs())
2224 SubstNonTypeTemplateParmExpr *E) {
2225 VisitExpr(E);
2226 Record.AddDeclRef(E->getAssociatedDecl());
2227 CurrentPackingBits.addBit(E->isReferenceParameter());
2228 CurrentPackingBits.addBits(E->getIndex(), /*Width=*/12);
2229 CurrentPackingBits.addBit((bool)E->getPackIndex());
2230 if (auto PackIndex = E->getPackIndex())
2233 Record.AddSourceLocation(E->getNameLoc());
2234 Record.AddStmt(E->getReplacement());
2239 SubstNonTypeTemplateParmPackExpr *E) {
2240 VisitExpr(E);
2241 Record.AddDeclRef(E->getAssociatedDecl());
2242 Record.push_back(E->getIndex());
2243 Record.AddTemplateArgument(E->getArgumentPack());
2244 Record.AddSourceLocation(E->getParameterPackLocation());
2248 void ASTStmtWriter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
2249 VisitExpr(E);
2250 Record.push_back(E->getNumExpansions());
2251 Record.AddDeclRef(E->getParameterPack());
2252 Record.AddSourceLocation(E->getParameterPackLocation());
2253 for (FunctionParmPackExpr::iterator I = E->begin(), End = E->end();
2259 void ASTStmtWriter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
2260 VisitExpr(E);
2261 Record.push_back(static_cast<bool>(E->getLifetimeExtendedTemporaryDecl()));
2262 if (E->getLifetimeExtendedTemporaryDecl())
2263 Record.AddDeclRef(E->getLifetimeExtendedTemporaryDecl());
2265 Record.AddStmt(E->getSubExpr());
2269 void ASTStmtWriter::VisitCXXFoldExpr(CXXFoldExpr *E) {
2270 VisitExpr(E);
2271 Record.AddSourceLocation(E->LParenLoc);
2272 Record.AddSourceLocation(E->EllipsisLoc);
2273 Record.AddSourceLocation(E->RParenLoc);
2274 Record.push_back(E->NumExpansions);
2275 Record.AddStmt(E->SubExprs[0]);
2276 Record.AddStmt(E->SubExprs[1]);
2277 Record.AddStmt(E->SubExprs[2]);
2278 Record.push_back(E->Opcode);
2282 void ASTStmtWriter::VisitCXXParenListInitExpr(CXXParenListInitExpr *E) {
2283 VisitExpr(E);
2284 ArrayRef<Expr *> InitExprs = E->getInitExprs();
2286 Record.push_back(E->getUserSpecifiedInitExprs().size());
2287 Record.AddSourceLocation(E->getInitLoc());
2288 Record.AddSourceLocation(E->getBeginLoc());
2289 Record.AddSourceLocation(E->getEndLoc());
2290 for (Expr *InitExpr : E->getInitExprs())
2292 Expr *ArrayFiller = E->getArrayFiller();
2293 FieldDecl *UnionField = E->getInitializedFieldInUnion();
2306 void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
2307 VisitExpr(E);
2308 Record.AddStmt(E->getSourceExpr());
2309 Record.AddSourceLocation(E->getLocation());
2310 Record.push_back(E->isUnique());
2314 void ASTStmtWriter::VisitTypoExpr(TypoExpr *E) {
2315 VisitExpr(E);
2324 void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
2325 VisitCallExpr(E);
2326 Record.AddStmt(E->getConfig());
2333 void ASTStmtWriter::VisitAsTypeExpr(AsTypeExpr *E) {
2334 VisitExpr(E);
2335 Record.AddSourceLocation(E->getBuiltinLoc());
2336 Record.AddSourceLocation(E->getRParenLoc());
2337 Record.AddStmt(E->getSrcExpr());
2344 void ASTStmtWriter::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
2345 VisitExpr(E);
2346 Record.push_back(E->isArrow());
2347 Record.AddStmt(E->getBaseExpr());
2348 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
2349 Record.AddSourceLocation(E->getMemberLoc());
2350 Record.AddDeclRef(E->getPropertyDecl());
2354 void ASTStmtWriter::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
2355 VisitExpr(E);
2356 Record.AddStmt(E->getBase());
2357 Record.AddStmt(E->getIdx());
2358 Record.AddSourceLocation(E->getRBracketLoc());
2362 void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
2363 VisitExpr(E);
2364 Record.AddSourceRange(E->getSourceRange());
2365 Record.AddDeclRef(E->getGuidDecl());
2366 if (E->isTypeOperand()) {
2367 Record.AddTypeSourceInfo(E->getTypeOperandSourceInfo());
2370 Record.AddStmt(E->getExprOperand());
2416 void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
2417 Record.writeOMPChildren(E->Data);
2418 Record.AddSourceLocation(E->getBeginLoc());
2419 Record.AddSourceLocation(E->getEndLoc());
3004 for(Expr *E : S->getExprs())
3005 Record.AddStmt(E);