Lines Matching full:e
442 void ASTStmtWriter::VisitCoroutineSuspendExpr(CoroutineSuspendExpr *E) {
443 VisitExpr(E);
444 Record.AddSourceLocation(E->getKeywordLoc());
445 for (Stmt *S : E->children())
447 Record.AddStmt(E->getOpaqueValue());
450 void ASTStmtWriter::VisitCoawaitExpr(CoawaitExpr *E) {
451 VisitCoroutineSuspendExpr(E);
452 Record.push_back(E->isImplicit());
456 void ASTStmtWriter::VisitCoyieldExpr(CoyieldExpr *E) {
457 VisitCoroutineSuspendExpr(E);
461 void ASTStmtWriter::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) {
462 VisitExpr(E);
463 Record.AddSourceLocation(E->getKeywordLoc());
464 for (Stmt *S : E->children())
477 auto *E = DetailRecord.dyn_cast<Expr *>();
478 Record.push_back(/* IsDiagnostic */ E == nullptr);
479 if (E)
480 Record.AddStmt(E);
500 ConceptSpecializationExpr *E) {
501 VisitExpr(E);
502 Record.AddDeclRef(E->getSpecializationDecl());
503 const ConceptReference *CR = E->getConceptReference();
507 if (!E->isValueDependent())
508 addConstraintSatisfaction(Record, E->getSatisfaction());
513 void ASTStmtWriter::VisitRequiresExpr(RequiresExpr *E) {
514 VisitExpr(E);
515 Record.push_back(E->getLocalParameters().size());
516 Record.push_back(E->getRequirements().size());
517 Record.AddSourceLocation(E->RequiresExprBits.RequiresKWLoc);
518 Record.push_back(E->RequiresExprBits.IsSatisfied);
519 Record.AddDeclRef(E->getBody());
520 for (ParmVarDecl *P : E->getLocalParameters())
522 for (concepts::Requirement *R : E->getRequirements()) {
571 Record.AddSourceLocation(E->getLParenLoc());
572 Record.AddSourceLocation(E->getRParenLoc());
573 Record.AddSourceLocation(E->getEndLoc());
610 void ASTStmtWriter::VisitExpr(Expr *E) {
611 VisitStmt(E);
614 CurrentPackingBits.addBits(E->getDependence(), /*BitsWidth=*/5);
615 CurrentPackingBits.addBits(E->getValueKind(), /*BitsWidth=*/2);
616 CurrentPackingBits.addBits(E->getObjectKind(), /*BitsWidth=*/3);
618 Record.AddTypeRef(E->getType());
621 void ASTStmtWriter::VisitConstantExpr(ConstantExpr *E) {
622 VisitExpr(E);
623 Record.push_back(E->ConstantExprBits.ResultKind);
625 Record.push_back(E->ConstantExprBits.APValueKind);
626 Record.push_back(E->ConstantExprBits.IsUnsigned);
627 Record.push_back(E->ConstantExprBits.BitWidth);
629 Record.push_back(E->ConstantExprBits.IsImmediateInvocation);
631 switch (E->getResultStorageKind()) {
635 Record.push_back(E->Int64Result());
638 Record.AddAPValue(E->APValueResult());
642 Record.AddStmt(E->getSubExpr());
646 void ASTStmtWriter::VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E) {
647 VisitExpr(E);
649 Record.AddSourceLocation(E->getLocation());
650 Record.AddSourceLocation(E->getLParenLocation());
651 Record.AddSourceLocation(E->getRParenLocation());
652 Record.AddTypeSourceInfo(E->getTypeSourceInfo());
657 void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) {
658 VisitExpr(E);
660 bool HasFunctionName = E->getFunctionName() != nullptr;
663 llvm::to_underlying(E->getIdentKind())); // FIXME: stable encoding
664 Record.push_back(E->isTransparent());
665 Record.AddSourceLocation(E->getLocation());
667 Record.AddStmt(E->getFunctionName());
671 void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) {
672 VisitExpr(E);
676 CurrentPackingBits.addBit(E->hadMultipleCandidates());
677 CurrentPackingBits.addBit(E->refersToEnclosingVariableOrCapture());
678 CurrentPackingBits.addBits(E->isNonOdrUse(), /*Width=*/2);
679 CurrentPackingBits.addBit(E->isImmediateEscalating());
680 CurrentPackingBits.addBit(E->getDecl() != E->getFoundDecl());
681 CurrentPackingBits.addBit(E->hasQualifier());
682 CurrentPackingBits.addBit(E->hasTemplateKWAndArgsInfo());
684 if (E->hasTemplateKWAndArgsInfo()) {
685 unsigned NumTemplateArgs = E->getNumTemplateArgs();
689 DeclarationName::NameKind nk = (E->getDecl()->getDeclName().getNameKind());
691 if ((!E->hasTemplateKWAndArgsInfo()) && (!E->hasQualifier()) &&
692 (E->getDecl() == E->getFoundDecl()) &&
693 nk == DeclarationName::Identifier && E->getObjectKind() == OK_Ordinary) {
697 if (E->hasQualifier())
698 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
700 if (E->getDecl() != E->getFoundDecl())
701 Record.AddDeclRef(E->getFoundDecl());
703 if (E->hasTemplateKWAndArgsInfo())
704 AddTemplateKWAndArgsInfo(*E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
705 E->getTrailingObjects<TemplateArgumentLoc>());
707 Record.AddDeclRef(E->getDecl());
708 Record.AddSourceLocation(E->getLocation());
709 Record.AddDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName());
713 void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) {
714 VisitExpr(E);
715 Record.AddSourceLocation(E->getLocation());
716 Record.AddAPInt(E->getValue());
718 if (E->getValue().getBitWidth() == 32) {
725 void ASTStmtWriter::VisitFixedPointLiteral(FixedPointLiteral *E) {
726 VisitExpr(E);
727 Record.AddSourceLocation(E->getLocation());
728 Record.push_back(E->getScale());
729 Record.AddAPInt(E->getValue());
733 void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) {
734 VisitExpr(E);
735 Record.push_back(E->getRawSemantics());
736 Record.push_back(E->isExact());
737 Record.AddAPFloat(E->getValue());
738 Record.AddSourceLocation(E->getLocation());
742 void ASTStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
743 VisitExpr(E);
744 Record.AddStmt(E->getSubExpr());
748 void ASTStmtWriter::VisitStringLiteral(StringLiteral *E) {
749 VisitExpr(E);
752 Record.push_back(E->getNumConcatenated());
753 Record.push_back(E->getLength());
754 Record.push_back(E->getCharByteWidth());
755 Record.push_back(llvm::to_underlying(E->getKind()));
756 Record.push_back(E->isPascal());
759 for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
760 Record.AddSourceLocation(E->getStrTokenLoc(I));
763 StringRef StrData = E->getBytes();
764 for (unsigned I = 0, N = E->getByteLength(); I != N; ++I)
770 void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) {
771 VisitExpr(E);
772 Record.push_back(E->getValue());
773 Record.AddSourceLocation(E->getLocation());
774 Record.push_back(llvm::to_underlying(E->getKind()));
781 void ASTStmtWriter::VisitParenExpr(ParenExpr *E) {
782 VisitExpr(E);
783 Record.AddSourceLocation(E->getLParen());
784 Record.AddSourceLocation(E->getRParen());
785 Record.AddStmt(E->getSubExpr());
789 void ASTStmtWriter::VisitParenListExpr(ParenListExpr *E) {
790 VisitExpr(E);
791 Record.push_back(E->getNumExprs());
792 for (auto *SubStmt : E->exprs())
794 Record.AddSourceLocation(E->getLParenLoc());
795 Record.AddSourceLocation(E->getRParenLoc());
799 void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) {
800 VisitExpr(E);
801 bool HasFPFeatures = E->hasStoredFPFeatures();
805 Record.AddStmt(E->getSubExpr());
806 CurrentPackingBits.addBits(E->getOpcode(),
808 Record.AddSourceLocation(E->getOperatorLoc());
809 CurrentPackingBits.addBit(E->canOverflow());
812 Record.push_back(E->getStoredFPFeatures().getAsOpaqueInt());
816 void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) {
817 VisitExpr(E);
818 Record.push_back(E->getNumComponents());
819 Record.push_back(E->getNumExpressions());
820 Record.AddSourceLocation(E->getOperatorLoc());
821 Record.AddSourceLocation(E->getRParenLoc());
822 Record.AddTypeSourceInfo(E->getTypeSourceInfo());
823 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
824 const OffsetOfNode &ON = E->getComponent(I);
846 for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
847 Record.AddStmt(E->getIndexExpr(I));
851 void ASTStmtWriter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
852 VisitExpr(E);
853 Record.push_back(E->getKind());
854 if (E->isArgumentType())
855 Record.AddTypeSourceInfo(E->getArgumentTypeInfo());
858 Record.AddStmt(E->getArgumentExpr());
860 Record.AddSourceLocation(E->getOperatorLoc());
861 Record.AddSourceLocation(E->getRParenLoc());
865 void ASTStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
866 VisitExpr(E);
867 Record.AddStmt(E->getLHS());
868 Record.AddStmt(E->getRHS());
869 Record.AddSourceLocation(E->getRBracketLoc());
873 void ASTStmtWriter::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E) {
874 VisitExpr(E);
875 Record.AddStmt(E->getBase());
876 Record.AddStmt(E->getRowIdx());
877 Record.AddStmt(E->getColumnIdx());
878 Record.AddSourceLocation(E->getRBracketLoc());
882 void ASTStmtWriter::VisitArraySectionExpr(ArraySectionExpr *E) {
883 VisitExpr(E);
884 Record.writeEnum(E->ASType);
885 Record.AddStmt(E->getBase());
886 Record.AddStmt(E->getLowerBound());
887 Record.AddStmt(E->getLength());
888 if (E->isOMPArraySection())
889 Record.AddStmt(E->getStride());
890 Record.AddSourceLocation(E->getColonLocFirst());
892 if (E->isOMPArraySection())
893 Record.AddSourceLocation(E->getColonLocSecond());
895 Record.AddSourceLocation(E->getRBracketLoc());
899 void ASTStmtWriter::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *E) {
900 VisitExpr(E);
901 Record.push_back(E->getDimensions().size());
902 Record.AddStmt(E->getBase());
903 for (Expr *Dim : E->getDimensions())
905 for (SourceRange SR : E->getBracketsRanges())
907 Record.AddSourceLocation(E->getLParenLoc());
908 Record.AddSourceLocation(E->getRParenLoc());
912 void ASTStmtWriter::VisitOMPIteratorExpr(OMPIteratorExpr *E) {
913 VisitExpr(E);
914 Record.push_back(E->numOfIterators());
915 Record.AddSourceLocation(E->getIteratorKwLoc());
916 Record.AddSourceLocation(E->getLParenLoc());
917 Record.AddSourceLocation(E->getRParenLoc());
918 for (unsigned I = 0, End = E->numOfIterators(); I < End; ++I) {
919 Record.AddDeclRef(E->getIteratorDecl(I));
920 Record.AddSourceLocation(E->getAssignLoc(I));
921 OMPIteratorExpr::IteratorRange Range = E->getIteratorRange(I);
925 Record.AddSourceLocation(E->getColonLoc(I));
927 Record.AddSourceLocation(E->getSecondColonLoc(I));
929 OMPIteratorHelperData &HD = E->getHelper(I);
938 void ASTStmtWriter::VisitCallExpr(CallExpr *E) {
939 VisitExpr(E);
941 Record.push_back(E->getNumArgs());
943 CurrentPackingBits.addBit(static_cast<bool>(E->getADLCallKind()));
944 CurrentPackingBits.addBit(E->hasStoredFPFeatures());
946 Record.AddSourceLocation(E->getRParenLoc());
947 Record.AddStmt(E->getCallee());
948 for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
952 if (E->hasStoredFPFeatures())
953 Record.push_back(E->getFPFeatures().getAsOpaqueInt());
955 if (!E->hasStoredFPFeatures() && !static_cast<bool>(E->getADLCallKind()) &&
956 E->getStmtClass() == Stmt::CallExprClass)
962 void ASTStmtWriter::VisitRecoveryExpr(RecoveryExpr *E) {
963 VisitExpr(E);
964 Record.push_back(std::distance(E->children().begin(), E->children().end()));
965 Record.AddSourceLocation(E->getBeginLoc());
966 Record.AddSourceLocation(E->getEndLoc());
967 for (Stmt *Child : E->children())
972 void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) {
973 VisitExpr(E);
975 bool HasQualifier = E->hasQualifier();
976 bool HasFoundDecl = E->hasFoundDecl();
977 bool HasTemplateInfo = E->hasTemplateKWAndArgsInfo();
978 unsigned NumTemplateArgs = E->getNumTemplateArgs();
988 Record.AddStmt(E->getBase());
989 Record.AddDeclRef(E->getMemberDecl());
990 Record.AddDeclarationNameLoc(E->MemberDNLoc,
991 E->getMemberDecl()->getDeclName());
992 Record.AddSourceLocation(E->getMemberLoc());
993 CurrentPackingBits.addBit(E->isArrow());
994 CurrentPackingBits.addBit(E->hadMultipleCandidates());
995 CurrentPackingBits.addBits(E->isNonOdrUse(), /*Width=*/2);
996 Record.AddSourceLocation(E->getOperatorLoc());
999 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
1002 DeclAccessPair FoundDecl = E->getFoundDecl();
1008 AddTemplateKWAndArgsInfo(*E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1009 E->getTrailingObjects<TemplateArgumentLoc>());
1014 void ASTStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) {
1015 VisitExpr(E);
1016 Record.AddStmt(E->getBase());
1017 Record.AddSourceLocation(E->getIsaMemberLoc());
1018 Record.AddSourceLocation(E->getOpLoc());
1019 Record.push_back(E->isArrow());
1024 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
1025 VisitExpr(E);
1026 Record.AddStmt(E->getSubExpr());
1027 Record.push_back(E->shouldCopy());
1031 void ASTStmtWriter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
1032 VisitExplicitCastExpr(E);
1033 Record.AddSourceLocation(E->getLParenLoc());
1034 Record.AddSourceLocation(E->getBridgeKeywordLoc());
1035 Record.push_back(E->getBridgeKind()); // FIXME: Stable encoding
1039 void ASTStmtWriter::VisitCastExpr(CastExpr *E) {
1040 VisitExpr(E);
1042 Record.push_back(E->path_size());
1045 CurrentPackingBits.addBits(E->getCastKind(), /*Width=*/7);
1046 CurrentPackingBits.addBit(E->hasStoredFPFeatures());
1047 Record.AddStmt(E->getSubExpr());
1050 PI = E->path_begin(), PE = E->path_end(); PI != PE; ++PI)
1053 if (E->hasStoredFPFeatures())
1054 Record.push_back(E->getFPFeatures().getAsOpaqueInt());
1057 void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) {
1058 VisitExpr(E);
1063 CurrentPackingBits.addBits(E->getOpcode(), /*Width=*/6);
1064 bool HasFPFeatures = E->hasStoredFPFeatures();
1066 Record.AddStmt(E->getLHS());
1067 Record.AddStmt(E->getRHS());
1068 Record.AddSourceLocation(E->getOperatorLoc());
1070 Record.push_back(E->getStoredFPFeatures().getAsOpaqueInt());
1072 if (!HasFPFeatures && E->getValueKind() == VK_PRValue &&
1073 E->getObjectKind() == OK_Ordinary)
1079 void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
1080 VisitBinaryOperator(E);
1081 Record.AddTypeRef(E->getComputationLHSType());
1082 Record.AddTypeRef(E->getComputationResultType());
1084 if (!E->hasStoredFPFeatures() && E->getValueKind() == VK_PRValue &&
1085 E->getObjectKind() == OK_Ordinary)
1091 void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator *E) {
1092 VisitExpr(E);
1093 Record.AddStmt(E->getCond());
1094 Record.AddStmt(E->getLHS());
1095 Record.AddStmt(E->getRHS());
1096 Record.AddSourceLocation(E->getQuestionLoc());
1097 Record.AddSourceLocation(E->getColonLoc());
1102 ASTStmtWriter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
1103 VisitExpr(E);
1104 Record.AddStmt(E->getOpaqueValue());
1105 Record.AddStmt(E->getCommon());
1106 Record.AddStmt(E->getCond());
1107 Record.AddStmt(E->getTrueExpr());
1108 Record.AddStmt(E->getFalseExpr());
1109 Record.AddSourceLocation(E->getQuestionLoc());
1110 Record.AddSourceLocation(E->getColonLoc());
1114 void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
1115 VisitCastExpr(E);
1116 CurrentPackingBits.addBit(E->isPartOfExplicitCast());
1118 if (E->path_size() == 0 && !E->hasStoredFPFeatures())
1124 void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
1125 VisitCastExpr(E);
1126 Record.AddTypeSourceInfo(E->getTypeInfoAsWritten());
1129 void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) {
1130 VisitExplicitCastExpr(E);
1131 Record.AddSourceLocation(E->getLParenLoc());
1132 Record.AddSourceLocation(E->getRParenLoc());
1136 void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
1137 VisitExpr(E);
1138 Record.AddSourceLocation(E->getLParenLoc());
1139 Record.AddTypeSourceInfo(E->getTypeSourceInfo());
1140 Record.AddStmt(E->getInitializer());
1141 Record.push_back(E->isFileScope());
1145 void ASTStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
1146 VisitExpr(E);
1147 Record.AddStmt(E->getBase());
1148 Record.AddIdentifierRef(&E->getAccessor());
1149 Record.AddSourceLocation(E->getAccessorLoc());
1153 void ASTStmtWriter::VisitInitListExpr(InitListExpr *E) {
1154 VisitExpr(E);
1157 Record.AddStmt(E->getSyntacticForm());
1158 Record.AddSourceLocation(E->getLBraceLoc());
1159 Record.AddSourceLocation(E->getRBraceLoc());
1160 bool isArrayFiller = E->ArrayFillerOrUnionFieldInit.is<Expr*>();
1163 Record.AddStmt(E->getArrayFiller());
1165 Record.AddDeclRef(E->getInitializedFieldInUnion());
1166 Record.push_back(E->hadArrayRangeDesignator());
1167 Record.push_back(E->getNumInits());
1171 Expr *filler = E->getArrayFiller();
1172 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
1173 Record.AddStmt(E->getInit(I) != filler ? E->getInit(I) : nullptr);
1175 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
1176 Record.AddStmt(E->getInit(I));
1181 void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
1182 VisitExpr(E);
1183 Record.push_back(E->getNumSubExprs());
1184 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
1185 Record.AddStmt(E->getSubExpr(I));
1186 Record.AddSourceLocation(E->getEqualOrColonLoc());
1187 Record.push_back(E->usesGNUSyntax());
1188 for (const DesignatedInitExpr::Designator &D : E->designators()) {
1216 void ASTStmtWriter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
1217 VisitExpr(E);
1218 Record.AddStmt(E->getBase());
1219 Record.AddStmt(E->getUpdater());
1223 void ASTStmtWriter::VisitNoInitExpr(NoInitExpr *E) {
1224 VisitExpr(E);
1228 void ASTStmtWriter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
1229 VisitExpr(E);
1230 Record.AddStmt(E->SubExprs[0]);
1231 Record.AddStmt(E->SubExprs[1]);
1235 void ASTStmtWriter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
1236 VisitExpr(E);
1240 void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
1241 VisitExpr(E);
1245 void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) {
1246 VisitExpr(E);
1247 Record.AddStmt(E->getSubExpr());
1248 Record.AddTypeSourceInfo(E->getWrittenTypeInfo());
1249 Record.AddSourceLocation(E->getBuiltinLoc());
1250 Record.AddSourceLocation(E->getRParenLoc());
1251 Record.push_back(E->isMicrosoftABI());
1255 void ASTStmtWriter::VisitSourceLocExpr(SourceLocExpr *E) {
1256 VisitExpr(E);
1257 Record.AddDeclRef(cast_or_null<Decl>(E->getParentContext()));
1258 Record.AddSourceLocation(E->getBeginLoc());
1259 Record.AddSourceLocation(E->getEndLoc());
1260 Record.push_back(llvm::to_underlying(E->getIdentKind()));
1264 void ASTStmtWriter::VisitEmbedExpr(EmbedExpr *E) {
1265 VisitExpr(E);
1266 Record.AddSourceLocation(E->getBeginLoc());
1267 Record.AddSourceLocation(E->getEndLoc());
1268 Record.AddStmt(E->getDataStringLiteral());
1269 Record.writeUInt32(E->getStartingElementPos());
1270 Record.writeUInt32(E->getDataElementCount());
1274 void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) {
1275 VisitExpr(E);
1276 Record.AddSourceLocation(E->getAmpAmpLoc());
1277 Record.AddSourceLocation(E->getLabelLoc());
1278 Record.AddDeclRef(E->getLabel());
1282 void ASTStmtWriter::VisitStmtExpr(StmtExpr *E) {
1283 VisitExpr(E);
1284 Record.AddStmt(E->getSubStmt());
1285 Record.AddSourceLocation(E->getLParenLoc());
1286 Record.AddSourceLocation(E->getRParenLoc());
1287 Record.push_back(E->getTemplateDepth());
1291 void ASTStmtWriter::VisitChooseExpr(ChooseExpr *E) {
1292 VisitExpr(E);
1293 Record.AddStmt(E->getCond());
1294 Record.AddStmt(E->getLHS());
1295 Record.AddStmt(E->getRHS());
1296 Record.AddSourceLocation(E->getBuiltinLoc());
1297 Record.AddSourceLocation(E->getRParenLoc());
1298 Record.push_back(E->isConditionDependent() ? false : E->isConditionTrue());
1302 void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) {
1303 VisitExpr(E);
1304 Record.AddSourceLocation(E->getTokenLocation());
1308 void ASTStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
1309 VisitExpr(E);
1310 Record.push_back(E->getNumSubExprs());
1311 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
1312 Record.AddStmt(E->getExpr(I));
1313 Record.AddSourceLocation(E->getBuiltinLoc());
1314 Record.AddSourceLocation(E->getRParenLoc());
1318 void ASTStmtWriter::VisitConvertVectorExpr(ConvertVectorExpr *E) {
1319 VisitExpr(E);
1320 Record.AddSourceLocation(E->getBuiltinLoc());
1321 Record.AddSourceLocation(E->getRParenLoc());
1322 Record.AddTypeSourceInfo(E->getTypeSourceInfo());
1323 Record.AddStmt(E->getSrcExpr());
1327 void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) {
1328 VisitExpr(E);
1329 Record.AddDeclRef(E->getBlockDecl());
1333 void ASTStmtWriter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
1334 VisitExpr(E);
1336 Record.push_back(E->getNumAssocs());
1337 Record.push_back(E->isExprPredicate());
1338 Record.push_back(E->ResultIndex);
1339 Record.AddSourceLocation(E->getGenericLoc());
1340 Record.AddSourceLocation(E->getDefaultLoc());
1341 Record.AddSourceLocation(E->getRParenLoc());
1343 Stmt **Stmts = E->getTrailingObjects<Stmt *>();
1347 for (unsigned I = 0, N = E->getNumAssocs() + 1; I < N; ++I)
1350 TypeSourceInfo **TSIs = E->getTrailingObjects<TypeSourceInfo *>();
1351 for (unsigned I = 0, N = E->getNumAssocs(); I < N; ++I)
1357 void ASTStmtWriter::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
1358 VisitExpr(E);
1359 Record.push_back(E->getNumSemanticExprs());
1363 unsigned result = E->getResultExprIndex();
1367 Record.AddStmt(E->getSyntacticForm());
1369 i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) {
1375 void ASTStmtWriter::VisitAtomicExpr(AtomicExpr *E) {
1376 VisitExpr(E);
1377 Record.push_back(E->getOp());
1378 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
1379 Record.AddStmt(E->getSubExprs()[I]);
1380 Record.AddSourceLocation(E->getBuiltinLoc());
1381 Record.AddSourceLocation(E->getRParenLoc());
1389 void ASTStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) {
1390 VisitExpr(E);
1391 Record.AddStmt(E->getString());
1392 Record.AddSourceLocation(E->getAtLoc());
1396 void ASTStmtWriter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
1397 VisitExpr(E);
1398 Record.AddStmt(E->getSubExpr());
1399 Record.AddDeclRef(E->getBoxingMethod());
1400 Record.AddSourceRange(E->getSourceRange());
1404 void ASTStmtWriter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
1405 VisitExpr(E);
1406 Record.push_back(E->getNumElements());
1407 for (unsigned i = 0; i < E->getNumElements(); i++)
1408 Record.AddStmt(E->getElement(i));
1409 Record.AddDeclRef(E->getArrayWithObjectsMethod());
1410 Record.AddSourceRange(E->getSourceRange());
1414 void ASTStmtWriter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
1415 VisitExpr(E);
1416 Record.push_back(E->getNumElements());
1417 Record.push_back(E->HasPackExpansions);
1418 for (unsigned i = 0; i < E->getNumElements(); i++) {
1419 ObjCDictionaryElement Element = E->getKeyValueElement(i);
1422 if (E->HasPackExpansions) {
1431 Record.AddDeclRef(E->getDictWithObjectsMethod());
1432 Record.AddSourceRange(E->getSourceRange());
1436 void ASTStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
1437 VisitExpr(E);
1438 Record.AddTypeSourceInfo(E->getEncodedTypeSourceInfo());
1439 Record.AddSourceLocation(E->getAtLoc());
1440 Record.AddSourceLocation(E->getRParenLoc());
1444 void ASTStmtWriter::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
1445 VisitExpr(E);
1446 Record.AddSelectorRef(E->getSelector());
1447 Record.AddSourceLocation(E->getAtLoc());
1448 Record.AddSourceLocation(E->getRParenLoc());
1452 void ASTStmtWriter::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
1453 VisitExpr(E);
1454 Record.AddDeclRef(E->getProtocol());
1455 Record.AddSourceLocation(E->getAtLoc());
1456 Record.AddSourceLocation(E->ProtoLoc);
1457 Record.AddSourceLocation(E->getRParenLoc());
1461 void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
1462 VisitExpr(E);
1463 Record.AddDeclRef(E->getDecl());
1464 Record.AddSourceLocation(E->getLocation());
1465 Record.AddSourceLocation(E->getOpLoc());
1466 Record.AddStmt(E->getBase());
1467 Record.push_back(E->isArrow());
1468 Record.push_back(E->isFreeIvar());
1472 void ASTStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
1473 VisitExpr(E);
1474 Record.push_back(E->SetterAndMethodRefFlags.getInt());
1475 Record.push_back(E->isImplicitProperty());
1476 if (E->isImplicitProperty()) {
1477 Record.AddDeclRef(E->getImplicitPropertyGetter());
1478 Record.AddDeclRef(E->getImplicitPropertySetter());
1480 Record.AddDeclRef(E->getExplicitProperty());
1482 Record.AddSourceLocation(E->getLocation());
1483 Record.AddSourceLocation(E->getReceiverLocation());
1484 if (E->isObjectReceiver()) {
1486 Record.AddStmt(E->getBase());
1487 } else if (E->isSuperReceiver()) {
1489 Record.AddTypeRef(E->getSuperReceiverType());
1492 Record.AddDeclRef(E->getClassReceiver());
1498 void ASTStmtWriter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1499 VisitExpr(E);
1500 Record.AddSourceLocation(E->getRBracket());
1501 Record.AddStmt(E->getBaseExpr());
1502 Record.AddStmt(E->getKeyExpr());
1503 Record.AddDeclRef(E->getAtIndexMethodDecl());
1504 Record.AddDeclRef(E->setAtIndexMethodDecl());
1509 void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1510 VisitExpr(E);
1511 Record.push_back(E->getNumArgs());
1512 Record.push_back(E->getNumStoredSelLocs());
1513 Record.push_back(E->SelLocsKind);
1514 Record.push_back(E->isDelegateInitCall());
1515 Record.push_back(E->IsImplicit);
1516 Record.push_back((unsigned)E->getReceiverKind()); // FIXME: stable encoding
1517 switch (E->getReceiverKind()) {
1519 Record.AddStmt(E->getInstanceReceiver());
1523 Record.AddTypeSourceInfo(E->getClassReceiverTypeInfo());
1528 Record.AddTypeRef(E->getSuperType());
1529 Record.AddSourceLocation(E->getSuperLoc());
1533 if (E->getMethodDecl()) {
1535 Record.AddDeclRef(E->getMethodDecl());
1538 Record.AddSelectorRef(E->getSelector());
1541 Record.AddSourceLocation(E->getLeftLoc());
1542 Record.AddSourceLocation(E->getRightLoc());
1544 for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
1548 SourceLocation *Locs = E->getStoredSelLocs();
1549 for (unsigned i = 0, e = E->getNumStoredSelLocs(); i != e; ++i)
1616 void ASTStmtWriter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1617 VisitExpr(E);
1618 Record.push_back(E->getValue());
1619 Record.AddSourceLocation(E->getLocation());
1623 void ASTStmtWriter::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
1624 VisitExpr(E);
1625 Record.AddSourceRange(E->getSourceRange());
1626 Record.AddVersionTuple(E->getVersion());
1647 for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1679 void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1680 VisitCallExpr(E);
1681 Record.push_back(E->getOperator());
1682 Record.AddSourceRange(E->Range);
1684 if (!E->hasStoredFPFeatures() && !static_cast<bool>(E->getADLCallKind()))
1690 void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
1691 VisitCallExpr(E);
1693 if (!E->hasStoredFPFeatures() && !static_cast<bool>(E->getADLCallKind()))
1700 CXXRewrittenBinaryOperator *E) {
1701 VisitExpr(E);
1702 Record.push_back(E->isReversed());
1703 Record.AddStmt(E->getSemanticForm());
1707 void ASTStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) {
1708 VisitExpr(E);
1710 Record.push_back(E->getNumArgs());
1711 Record.push_back(E->isElidable());
1712 Record.push_back(E->hadMultipleCandidates());
1713 Record.push_back(E->isListInitialization());
1714 Record.push_back(E->isStdInitListInitialization());
1715 Record.push_back(E->requiresZeroInitialization());
1717 llvm::to_underlying(E->getConstructionKind())); // FIXME: stable encoding
1718 Record.push_back(E->isImmediateEscalating());
1719 Record.AddSourceLocation(E->getLocation());
1720 Record.AddDeclRef(E->getConstructor());
1721 Record.AddSourceRange(E->getParenOrBraceRange());
1723 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1724 Record.AddStmt(E->getArg(I));
1729 void ASTStmtWriter::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
1730 VisitExpr(E);
1731 Record.AddDeclRef(E->getConstructor());
1732 Record.AddSourceLocation(E->getLocation());
1733 Record.push_back(E->constructsVBase());
1734 Record.push_back(E->inheritedFromVBase());
1738 void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1739 VisitCXXConstructExpr(E);
1740 Record.AddTypeSourceInfo(E->getTypeSourceInfo());
1744 void ASTStmtWriter::VisitLambdaExpr(LambdaExpr *E) {
1745 VisitExpr(E);
1746 Record.push_back(E->LambdaExprBits.NumCaptures);
1747 Record.AddSourceRange(E->IntroducerRange);
1748 Record.push_back(E->LambdaExprBits.CaptureDefault); // FIXME: stable encoding
1749 Record.AddSourceLocation(E->CaptureDefaultLoc);
1750 Record.push_back(E->LambdaExprBits.ExplicitParams);
1751 Record.push_back(E->LambdaExprBits.ExplicitResultType);
1752 Record.AddSourceLocation(E->ClosingBrace);
1755 for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
1756 CEnd = E->capture_init_end();
1767 void ASTStmtWriter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1768 VisitExpr(E);
1769 Record.AddStmt(E->getSubExpr());
1773 void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1774 VisitExplicitCastExpr(E);
1775 Record.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc()));
1776 CurrentPackingBits.addBit(E->getAngleBrackets().isValid());
1777 if (E->getAngleBrackets().isValid())
1778 Record.AddSourceRange(E->getAngleBrackets());
1781 void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1782 VisitCXXNamedCastExpr(E);
1786 void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1787 VisitCXXNamedCastExpr(E);
1791 void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1792 VisitCXXNamedCastExpr(E);
1796 void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1797 VisitCXXNamedCastExpr(E);
1801 void ASTStmtWriter::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) {
1802 VisitCXXNamedCastExpr(E);
1806 void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1807 VisitExplicitCastExpr(E);
1808 Record.AddSourceLocation(E->getLParenLoc());
1809 Record.AddSourceLocation(E->getRParenLoc());
1813 void ASTStmtWriter::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) {
1814 VisitExplicitCastExpr(E);
1815 Record.AddSourceLocation(E->getBeginLoc());
1816 Record.AddSourceLocation(E->getEndLoc());
1820 void ASTStmtWriter::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1821 VisitCallExpr(E);
1822 Record.AddSourceLocation(E->UDSuffixLoc);
1826 void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1827 VisitExpr(E);
1828 Record.push_back(E->getValue());
1829 Record.AddSourceLocation(E->getLocation());
1833 void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1834 VisitExpr(E);
1835 Record.AddSourceLocation(E->getLocation());
1839 void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1840 VisitExpr(E);
1841 Record.AddSourceRange(E->getSourceRange());
1842 if (E->isTypeOperand()) {
1843 Record.AddTypeSourceInfo(E->getTypeOperandSourceInfo());
1846 Record.AddStmt(E->getExprOperand());
1851 void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) {
1852 VisitExpr(E);
1853 Record.AddSourceLocation(E->getLocation());
1854 Record.push_back(E->isImplicit());
1855 Record.push_back(E->isCapturedByCopyInLambdaWithExplicitObjectParameter());
1860 void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) {
1861 VisitExpr(E);
1862 Record.AddSourceLocation(E->getThrowLoc());
1863 Record.AddStmt(E->getSubExpr());
1864 Record.push_back(E->isThrownVariableInScope());
1868 void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1869 VisitExpr(E);
1870 Record.AddDeclRef(E->getParam());
1871 Record.AddDeclRef(cast_or_null<Decl>(E->getUsedContext()));
1872 Record.AddSourceLocation(E->getUsedLocation());
1873 Record.push_back(E->hasRewrittenInit());
1874 if (E->hasRewrittenInit())
1875 Record.AddStmt(E->getRewrittenExpr());
1879 void ASTStmtWriter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1880 VisitExpr(E);
1881 Record.push_back(E->hasRewrittenInit());
1882 Record.AddDeclRef(E->getField());
1883 Record.AddDeclRef(cast_or_null<Decl>(E->getUsedContext()));
1884 Record.AddSourceLocation(E->getExprLoc());
1885 if (E->hasRewrittenInit())
1886 Record.AddStmt(E->getRewrittenExpr());
1890 void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1891 VisitExpr(E);
1892 Record.AddCXXTemporary(E->getTemporary());
1893 Record.AddStmt(E->getSubExpr());
1897 void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1898 VisitExpr(E);
1899 Record.AddTypeSourceInfo(E->getTypeSourceInfo());
1900 Record.AddSourceLocation(E->getRParenLoc());
1904 void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) {
1905 VisitExpr(E);
1907 Record.push_back(E->isArray());
1908 Record.push_back(E->hasInitializer());
1909 Record.push_back(E->getNumPlacementArgs());
1910 Record.push_back(E->isParenTypeId());
1912 Record.push_back(E->isGlobalNew());
1913 Record.push_back(E->passAlignment());
1914 Record.push_back(E->doesUsualArrayDeleteWantSize());
1915 Record.push_back(E->CXXNewExprBits.HasInitializer);
1916 Record.push_back(E->CXXNewExprBits.StoredInitializationStyle);
1918 Record.AddDeclRef(E->getOperatorNew());
1919 Record.AddDeclRef(E->getOperatorDelete());
1920 Record.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo());
1921 if (E->isParenTypeId())
1922 Record.AddSourceRange(E->getTypeIdParens());
1923 Record.AddSourceRange(E->getSourceRange());
1924 Record.AddSourceRange(E->getDirectInitRange());
1926 for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), N = E->raw_arg_end();
1933 void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1934 VisitExpr(E);
1935 Record.push_back(E->isGlobalDelete());
1936 Record.push_back(E->isArrayForm());
1937 Record.push_back(E->isArrayFormAsWritten());
1938 Record.push_back(E->doesUsualArrayDeleteWantSize());
1939 Record.AddDeclRef(E->getOperatorDelete());
1940 Record.AddStmt(E->getArgument());
1941 Record.AddSourceLocation(E->getBeginLoc());
1946 void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1947 VisitExpr(E);
1949 Record.AddStmt(E->getBase());
1950 Record.push_back(E->isArrow());
1951 Record.AddSourceLocation(E->getOperatorLoc());
1952 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
1953 Record.AddTypeSourceInfo(E->getScopeTypeInfo());
1954 Record.AddSourceLocation(E->getColonColonLoc());
1955 Record.AddSourceLocation(E->getTildeLoc());
1958 Record.AddIdentifierRef(E->getDestroyedTypeIdentifier());
1959 if (E->getDestroyedTypeIdentifier())
1960 Record.AddSourceLocation(E->getDestroyedTypeLoc());
1962 Record.AddTypeSourceInfo(E->getDestroyedTypeInfo());
1967 void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) {
1968 VisitExpr(E);
1969 Record.push_back(E->getNumObjects());
1970 for (auto &Obj : E->getObjects()) {
1980 Record.push_back(E->cleanupsHaveSideEffects());
1981 Record.AddStmt(E->getSubExpr());
1986 CXXDependentScopeMemberExpr *E) {
1987 VisitExpr(E);
1991 Record.push_back(E->getNumTemplateArgs());
1993 CurrentPackingBits.addBit(E->hasTemplateKWAndArgsInfo());
1994 CurrentPackingBits.addBit(E->hasFirstQualifierFoundInScope());
1996 if (E->hasTemplateKWAndArgsInfo()) {
1998 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
2000 E->getTrailingObjects<TemplateArgumentLoc>());
2003 CurrentPackingBits.addBit(E->isArrow());
2005 Record.AddTypeRef(E->getBaseType());
2006 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
2007 CurrentPackingBits.addBit(!E->isImplicitAccess());
2008 if (!E->isImplicitAccess())
2009 Record.AddStmt(E->getBase());
2011 Record.AddSourceLocation(E->getOperatorLoc());
2013 if (E->hasFirstQualifierFoundInScope())
2014 Record.AddDeclRef(E->getFirstQualifierFoundInScope());
2016 Record.AddDeclarationNameInfo(E->MemberNameInfo);
2021 ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
2022 VisitExpr(E);
2027 E->DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo);
2029 if (E->DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo) {
2031 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
2035 E->getTrailingObjects<TemplateArgumentLoc>());
2038 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
2039 Record.AddDeclarationNameInfo(E->NameInfo);
2044 ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
2045 VisitExpr(E);
2046 Record.push_back(E->getNumArgs());
2048 ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI)
2050 Record.AddTypeSourceInfo(E->getTypeSourceInfo());
2051 Record.AddSourceLocation(E->getLParenLoc());
2052 Record.AddSourceLocation(E->getRParenLoc());
2053 Record.push_back(E->isListInitialization());
2057 void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) {
2058 VisitExpr(E);
2060 Record.push_back(E->getNumDecls());
2063 CurrentPackingBits.addBit(E->hasTemplateKWAndArgsInfo());
2064 if (E->hasTemplateKWAndArgsInfo()) {
2066 *E->getTrailingASTTemplateKWAndArgsInfo();
2068 AddTemplateKWAndArgsInfo(ArgInfo, E->getTrailingTemplateArgumentLoc());
2071 for (OverloadExpr::decls_iterator OvI = E->decls_begin(),
2072 OvE = E->decls_end();
2078 Record.AddDeclarationNameInfo(E->getNameInfo());
2079 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
2082 void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
2083 VisitOverloadExpr(E);
2084 CurrentPackingBits.addBit(E->isArrow());
2085 CurrentPackingBits.addBit(E->hasUnresolvedUsing());
2086 CurrentPackingBits.addBit(!E->isImplicitAccess());
2087 if (!E->isImplicitAccess())
2088 Record.AddStmt(E->getBase());
2090 Record.AddSourceLocation(E->getOperatorLoc());
2092 Record.AddTypeRef(E->getBaseType());
2096 void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
2097 VisitOverloadExpr(E);
2098 CurrentPackingBits.addBit(E->requiresADL());
2099 Record.AddDeclRef(E->getNamingClass());
2105 DeclarationName Name = E->getName();
2119 void ASTStmtWriter::VisitTypeTraitExpr(TypeTraitExpr *E) {
2120 VisitExpr(E);
2121 Record.push_back(E->TypeTraitExprBits.NumArgs);
2122 Record.push_back(E->TypeTraitExprBits.Kind); // FIXME: Stable encoding
2123 Record.push_back(E->TypeTraitExprBits.Value);
2124 Record.AddSourceRange(E->getSourceRange());
2125 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
2126 Record.AddTypeSourceInfo(E->getArg(I));
2130 void ASTStmtWriter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
2131 VisitExpr(E);
2132 Record.push_back(E->getTrait());
2133 Record.push_back(E->getValue());
2134 Record.AddSourceRange(E->getSourceRange());
2135 Record.AddTypeSourceInfo(E->getQueriedTypeSourceInfo());
2136 Record.AddStmt(E->getDimensionExpression());
2140 void ASTStmtWriter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
2141 VisitExpr(E);
2142 Record.push_back(E->getTrait());
2143 Record.push_back(E->getValue());
2144 Record.AddSourceRange(E->getSourceRange());
2145 Record.AddStmt(E->getQueriedExpression());
2149 void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
2150 VisitExpr(E);
2151 Record.push_back(E->getValue());
2152 Record.AddSourceRange(E->getSourceRange());
2153 Record.AddStmt(E->getOperand());
2157 void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr *E) {
2158 VisitExpr(E);
2159 Record.AddSourceLocation(E->getEllipsisLoc());
2160 Record.push_back(E->NumExpansions);
2161 Record.AddStmt(E->getPattern());
2165 void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
2166 VisitExpr(E);
2167 Record.push_back(E->isPartiallySubstituted() ? E->getPartialArguments().size()
2169 Record.AddSourceLocation(E->OperatorLoc);
2170 Record.AddSourceLocation(E->PackLoc);
2171 Record.AddSourceLocation(E->RParenLoc);
2172 Record.AddDeclRef(E->Pack);
2173 if (E->isPartiallySubstituted()) {
2174 for (const auto &TA : E->getPartialArguments())
2176 } else if (!E->isValueDependent()) {
2177 Record.push_back(E->getPackLength());
2182 void ASTStmtWriter::VisitPackIndexingExpr(PackIndexingExpr *E) {
2183 VisitExpr(E);
2184 Record.push_back(E->TransformedExpressions);
2185 Record.push_back(E->ExpandedToEmptyPack);
2186 Record.AddSourceLocation(E->getEllipsisLoc());
2187 Record.AddSourceLocation(E->getRSquareLoc());
2188 Record.AddStmt(E->getPackIdExpression());
2189 Record.AddStmt(E->getIndexExpr());
2190 for (Expr *Sub : E->getExpressions())
2196 SubstNonTypeTemplateParmExpr *E) {
2197 VisitExpr(E);
2198 Record.AddDeclRef(E->getAssociatedDecl());
2199 CurrentPackingBits.addBit(E->isReferenceParameter());
2200 CurrentPackingBits.addBits(E->getIndex(), /*Width=*/12);
2201 CurrentPackingBits.addBit((bool)E->getPackIndex());
2202 if (auto PackIndex = E->getPackIndex())
2205 Record.AddSourceLocation(E->getNameLoc());
2206 Record.AddStmt(E->getReplacement());
2211 SubstNonTypeTemplateParmPackExpr *E) {
2212 VisitExpr(E);
2213 Record.AddDeclRef(E->getAssociatedDecl());
2214 Record.push_back(E->getIndex());
2215 Record.AddTemplateArgument(E->getArgumentPack());
2216 Record.AddSourceLocation(E->getParameterPackLocation());
2220 void ASTStmtWriter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
2221 VisitExpr(E);
2222 Record.push_back(E->getNumExpansions());
2223 Record.AddDeclRef(E->getParameterPack());
2224 Record.AddSourceLocation(E->getParameterPackLocation());
2225 for (FunctionParmPackExpr::iterator I = E->begin(), End = E->end();
2231 void ASTStmtWriter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
2232 VisitExpr(E);
2233 Record.push_back(static_cast<bool>(E->getLifetimeExtendedTemporaryDecl()));
2234 if (E->getLifetimeExtendedTemporaryDecl())
2235 Record.AddDeclRef(E->getLifetimeExtendedTemporaryDecl());
2237 Record.AddStmt(E->getSubExpr());
2241 void ASTStmtWriter::VisitCXXFoldExpr(CXXFoldExpr *E) {
2242 VisitExpr(E);
2243 Record.AddSourceLocation(E->LParenLoc);
2244 Record.AddSourceLocation(E->EllipsisLoc);
2245 Record.AddSourceLocation(E->RParenLoc);
2246 Record.push_back(E->NumExpansions);
2247 Record.AddStmt(E->SubExprs[0]);
2248 Record.AddStmt(E->SubExprs[1]);
2249 Record.AddStmt(E->SubExprs[2]);
2250 Record.push_back(E->Opcode);
2254 void ASTStmtWriter::VisitCXXParenListInitExpr(CXXParenListInitExpr *E) {
2255 VisitExpr(E);
2256 ArrayRef<Expr *> InitExprs = E->getInitExprs();
2258 Record.push_back(E->getUserSpecifiedInitExprs().size());
2259 Record.AddSourceLocation(E->getInitLoc());
2260 Record.AddSourceLocation(E->getBeginLoc());
2261 Record.AddSourceLocation(E->getEndLoc());
2262 for (Expr *InitExpr : E->getInitExprs())
2264 Expr *ArrayFiller = E->getArrayFiller();
2265 FieldDecl *UnionField = E->getInitializedFieldInUnion();
2278 void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
2279 VisitExpr(E);
2280 Record.AddStmt(E->getSourceExpr());
2281 Record.AddSourceLocation(E->getLocation());
2282 Record.push_back(E->isUnique());
2286 void ASTStmtWriter::VisitTypoExpr(TypoExpr *E) {
2287 VisitExpr(E);
2296 void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
2297 VisitCallExpr(E);
2298 Record.AddStmt(E->getConfig());
2305 void ASTStmtWriter::VisitAsTypeExpr(AsTypeExpr *E) {
2306 VisitExpr(E);
2307 Record.AddSourceLocation(E->getBuiltinLoc());
2308 Record.AddSourceLocation(E->getRParenLoc());
2309 Record.AddStmt(E->getSrcExpr());
2316 void ASTStmtWriter::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
2317 VisitExpr(E);
2318 Record.push_back(E->isArrow());
2319 Record.AddStmt(E->getBaseExpr());
2320 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());
2321 Record.AddSourceLocation(E->getMemberLoc());
2322 Record.AddDeclRef(E->getPropertyDecl());
2326 void ASTStmtWriter::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
2327 VisitExpr(E);
2328 Record.AddStmt(E->getBase());
2329 Record.AddStmt(E->getIdx());
2330 Record.AddSourceLocation(E->getRBracketLoc());
2334 void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
2335 VisitExpr(E);
2336 Record.AddSourceRange(E->getSourceRange());
2337 Record.AddDeclRef(E->getGuidDecl());
2338 if (E->isTypeOperand()) {
2339 Record.AddTypeSourceInfo(E->getTypeOperandSourceInfo());
2342 Record.AddStmt(E->getExprOperand());
2388 void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
2389 Record.writeOMPChildren(E->Data);
2390 Record.AddSourceLocation(E->getBeginLoc());
2391 Record.AddSourceLocation(E->getEndLoc());
2392 Record.writeEnum(E->getMappedDirective());