CbC/CbC_llvm: clang/lib/AST/DeclPrinter.cpp comparison

comparison clang/lib/AST/DeclPrinter.cpp @ 207:2e18cbf3894f

LLVM12

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Tue, 08 Jun 2021 06:07:14 +0900
parents	0572611fdcc8
children	5f17cb93ff66

comparison

equal deleted inserted replaced

-:0572611fdcc8
+:2e18cbf3894f
 void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *TTP);
 void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *NTTP);
 void printTemplateParameters(const TemplateParameterList *Params,
 bool OmitTemplateKW = false);
-void printTemplateArguments(llvm::ArrayRef<TemplateArgument> Args);
+void printTemplateArguments(llvm::ArrayRef<TemplateArgument> Args,
-void printTemplateArguments(llvm::ArrayRef<TemplateArgumentLoc> Args);
+const TemplateParameterList *Params,
+bool TemplOverloaded);
+void printTemplateArguments(llvm::ArrayRef<TemplateArgumentLoc> Args,
+const TemplateParameterList *Params,
+bool TemplOverloaded);
 void prettyPrintAttributes(Decl *D);
 void prettyPrintPragmas(Decl *D);
 void printDeclType(QualType T, StringRef DeclName, bool Pack = false);
 };
 }
 Decls.clear();
 }
 void DeclPrinter::Print(AccessSpecifier AS) {
-switch(AS) {
+const auto AccessSpelling = getAccessSpelling(AS);
-case AS_none:      llvm_unreachable("No access specifier!");
+if (AccessSpelling.empty())
-case AS_public:    Out << "public"; break;
+llvm_unreachable("No access specifier!");
-case AS_protected: Out << "protected"; break;
+Out << AccessSpelling;
-case AS_private:   Out << "private"; break;
-}
 }
 void DeclPrinter::PrintConstructorInitializers(CXXConstructorDecl *CDecl,
 std::string &Proto) {
 bool HasInitializerList = false;
 NumArgs = Construct->getNumArgs();
 } else
 SimpleInit = Init;
 if (SimpleInit)
-SimpleInit->printPretty(Out, nullptr, Policy, Indentation);
+SimpleInit->printPretty(Out, nullptr, Policy, Indentation, "\n",
+&Context);
 else {
 for (unsigned I = 0; I != NumArgs; ++I) {
 assert(Args[I] != nullptr && "Expected non-null Expr");
 if (isa<CXXDefaultArgExpr>(Args[I]))
 break;
 if (I)
 Out << ", ";
-Args[I]->printPretty(Out, nullptr, Policy, Indentation);
+Args[I]->printPretty(Out, nullptr, Policy, Indentation, "\n",
+&Context);
 }
 }
 }
 Out << ")";
 if (BMInitializer->isPackExpansion())
 Out << " struct";
 }
 prettyPrintAttributes(D);
-Out << ' ' << *D;
+if (D->getDeclName())
+Out << ' ' << D->getDeclName();
 if (D->isFixed())
 Out << " : " << D->getIntegerType().stream(Policy);
 if (D->isCompleteDefinition()) {
 Init->printPretty(Out, nullptr, Policy, Indentation, "\n", &Context);
 }
 }
 static void printExplicitSpecifier(ExplicitSpecifier ES, llvm::raw_ostream &Out,
-PrintingPolicy &Policy,
+PrintingPolicy &Policy, unsigned Indentation,
-unsigned Indentation) {
+const ASTContext &Context) {
 std::string Proto = "explicit";
 llvm::raw_string_ostream EOut(Proto);
 if (ES.getExpr()) {
 EOut << "(";
-ES.getExpr()->printPretty(EOut, nullptr, Policy, Indentation);
+ES.getExpr()->printPretty(EOut, nullptr, Policy, Indentation, "\n",
+&Context);
 EOut << ")";
 }
 EOut << " ";
 EOut.flush();
 Out << EOut.str();
 if (D->isConstexprSpecified() && !D->isExplicitlyDefaulted())
 Out << "constexpr ";
 if (D->isConsteval())        Out << "consteval ";
 ExplicitSpecifier ExplicitSpec = ExplicitSpecifier::getFromDecl(D);
 if (ExplicitSpec.isSpecified())
-printExplicitSpecifier(ExplicitSpec, Out, Policy, Indentation);
+printExplicitSpecifier(ExplicitSpec, Out, Policy, Indentation, Context);
 }
 PrintingPolicy SubPolicy(Policy);
 SubPolicy.SuppressSpecifiers = false;
 std::string Proto;
 Proto = GuideDecl->getDeducedTemplate()->getDeclName().getAsString();
 if (D->isFunctionTemplateSpecialization()) {
 llvm::raw_string_ostream POut(Proto);
 DeclPrinter TArgPrinter(POut, SubPolicy, Context, Indentation);
 const auto *TArgAsWritten = D->getTemplateSpecializationArgsAsWritten();
+const TemplateParameterList *TPL = D->getTemplateSpecializationInfo()
+->getTemplate()
+->getTemplateParameters();
 if (TArgAsWritten && !Policy.PrintCanonicalTypes)
-TArgPrinter.printTemplateArguments(TArgAsWritten->arguments());
+TArgPrinter.printTemplateArguments(TArgAsWritten->arguments(), TPL,
+/*TemplOverloaded*/ true);
 else if (const TemplateArgumentList *TArgs =
 D->getTemplateSpecializationArgs())
-TArgPrinter.printTemplateArguments(TArgs->asArray());
+TArgPrinter.printTemplateArguments(TArgs->asArray(), TPL,
+/*TemplOverloaded*/ true);
 }
 QualType Ty = D->getType();
 while (const ParenType *PT = dyn_cast<ParenType>(Ty)) {
 Proto = '(' + Proto + ')';
 Proto += " noexcept";
 if (isComputedNoexcept(FT->getExceptionSpecType())) {
 Proto += "(";
 llvm::raw_string_ostream EOut(Proto);
 FT->getNoexceptExpr()->printPretty(EOut, nullptr, SubPolicy,
-Indentation);
+Indentation, "\n", &Context);
 EOut.flush();
 Proto += EOut.str();
 Proto += ")";
 }
 }
 }
 Out << Proto;
 if (Expr *TrailingRequiresClause = D->getTrailingRequiresClause()) {
 Out << " requires ";
-TrailingRequiresClause->printPretty(Out, nullptr, SubPolicy, Indentation);
+TrailingRequiresClause->printPretty(Out, nullptr, SubPolicy, Indentation,
+"\n", &Context);
 }
 } else {
 Ty.print(Out, Policy, Proto);
 }
 Indentation -= Policy.Indentation;
 } else
 Out << ' ';
 if (D->getBody())
-D->getBody()->printPretty(Out, nullptr, SubPolicy, Indentation);
+D->getBody()->printPretty(Out, nullptr, SubPolicy, Indentation, "\n",
+&Context);
 } else {
 if (!Policy.TerseOutput && isa<CXXConstructorDecl>(*D))
 Out << " {}";
 }
 }
 Out << D->getASTContext().getUnqualifiedObjCPointerType(D->getType()).
 stream(Policy, D->getName(), Indentation);
 if (D->isBitField()) {
 Out << " : ";
-D->getBitWidth()->printPretty(Out, nullptr, Policy, Indentation);
+D->getBitWidth()->printPretty(Out, nullptr, Policy, Indentation, "\n",
+&Context);
 }
 Expr *Init = D->getInClassInitializer();
 if (!Policy.SuppressInitializers && Init) {
 if (D->getInClassInitStyle() == ICIS_ListInit)
 Out << " ";
 else
 Out << " = ";
-Init->printPretty(Out, nullptr, Policy, Indentation);
+Init->printPretty(Out, nullptr, Policy, Indentation, "\n", &Context);
 }
 prettyPrintAttributes(D);
 }
 void DeclPrinter::VisitLabelDecl(LabelDecl *D) {
 Out << " = ";
 }
 PrintingPolicy SubPolicy(Policy);
 SubPolicy.SuppressSpecifiers = false;
 SubPolicy.IncludeTagDefinition = false;
-Init->printPretty(Out, nullptr, SubPolicy, Indentation);
+Init->printPretty(Out, nullptr, SubPolicy, Indentation, "\n", &Context);
 if ((D->getInitStyle() == VarDecl::CallInit) && !isa<ParenListExpr>(Init))
 Out << ")";
 }
 }
 prettyPrintAttributes(D);
 VisitVarDecl(D);
 }
 void DeclPrinter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
 Out << "__asm (";
-D->getAsmString()->printPretty(Out, nullptr, Policy, Indentation);
+D->getAsmString()->printPretty(Out, nullptr, Policy, Indentation, "\n",
+&Context);
 Out << ")";
 }
 void DeclPrinter::VisitImportDecl(ImportDecl *D) {
 Out << "@import " << D->getImportedModule()->getFullModuleName()
 << ";\n";
 }
 void DeclPrinter::VisitStaticAssertDecl(StaticAssertDecl *D) {
 Out << "static_assert(";
-D->getAssertExpr()->printPretty(Out, nullptr, Policy, Indentation);
+D->getAssertExpr()->printPretty(Out, nullptr, Policy, Indentation, "\n",
+&Context);
 if (StringLiteral *SL = D->getMessage()) {
 Out << ", ";
-SL->printPretty(Out, nullptr, Policy, Indentation);
+SL->printPretty(Out, nullptr, Policy, Indentation, "\n", &Context);
 }
 Out << ")";
 }
 //----------------------------------------------------------------------------
 // C++ declarations
 //----------------------------------------------------------------------------
 void DeclPrinter::VisitNamespaceDecl(NamespaceDecl *D) {
 if (D->isInline())
 Out << "inline ";
-Out << "namespace " << *D << " {\n";
+Out << "namespace ";
+if (D->getDeclName())
+Out << D->getDeclName() << ' ';
+Out << "{\n";
 VisitDeclContext(D);
 Indent() << "}";
 }
 void DeclPrinter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
 if (!Policy.PrintCanonicalTypes)
 if (const auto* TSI = S->getTypeAsWritten())
 if (const auto *TST =
 dyn_cast<TemplateSpecializationType>(TSI->getType()))
 Args = TST->template_arguments();
-printTemplateArguments(Args);
+printTemplateArguments(
+Args, S->getSpecializedTemplate()->getTemplateParameters(),
+/*TemplOverloaded*/ false);
 }
 }
 if (D->isCompleteDefinition()) {
 // Print the base classes
 Out << '>';
 if (!OmitTemplateKW)
 Out << ' ';
 }
-void DeclPrinter::printTemplateArguments(ArrayRef<TemplateArgument> Args) {
+void DeclPrinter::printTemplateArguments(ArrayRef<TemplateArgument> Args,
+const TemplateParameterList *Params,
+bool TemplOverloaded) {
 Out << "<";
 for (size_t I = 0, E = Args.size(); I < E; ++I) {
 if (I)
 Out << ", ";
-Args[I].print(Policy, Out);
+if (TemplOverloaded || !Params)
+Args[I].print(Policy, Out, /*IncludeType*/ true);
+else
+Args[I].print(
+Policy, Out,
+TemplateParameterList::shouldIncludeTypeForArgument(Params, I));
 }
 Out << ">";
 }
-void DeclPrinter::printTemplateArguments(ArrayRef<TemplateArgumentLoc> Args) {
+void DeclPrinter::printTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
+const TemplateParameterList *Params,
+bool TemplOverloaded) {
 Out << "<";
 for (size_t I = 0, E = Args.size(); I < E; ++I) {
 if (I)
 Out << ", ";
-Args[I].getArgument().print(Policy, Out);
+if (TemplOverloaded)
+Args[I].getArgument().print(Policy, Out, /*IncludeType*/ true);
+else
+Args[I].getArgument().print(
+Policy, Out,
+TemplateParameterList::shouldIncludeTypeForArgument(Params, I));
 }
 Out << ">";
 }
 void DeclPrinter::VisitTemplateDecl(const TemplateDecl *D) {
 printTemplateParameters(D->getTemplateParameters());
 if (const TemplateTemplateParmDecl *TTP =
 dyn_cast<TemplateTemplateParmDecl>(D)) {
-Out << "class ";
+Out << "class";
 if (TTP->isParameterPack())
-Out << "...";
+Out << " ...";
-Out << D->getName();
+else if (TTP->getDeclName())
+Out << ' ';
+if (TTP->getDeclName())
+Out << TTP->getDeclName();
 } else if (auto *TD = D->getTemplatedDecl())
 Visit(TD);
 else if (const auto *Concept = dyn_cast<ConceptDecl>(D)) {
 Out << "concept " << Concept->getName() << " = " ;
-Concept->getConstraintExpr()->printPretty(Out, nullptr, Policy,
+Concept->getConstraintExpr()->printPretty(Out, nullptr, Policy, Indentation,
-Indentation);
+"\n", &Context);
 Out << ";";
 }
 }
 void DeclPrinter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
 case ObjCTypeParamVariance::Contravariant:
 Out << "__contravariant ";
 break;
 }
-Out << Param->getDeclName().getAsString();
+Out << Param->getDeclName();
 if (Param->hasExplicitBound()) {
 Out << " : " << Param->getUnderlyingType().getAsString(Policy);
 }
 }
 prettyPrintAttributes(OMD);
 if (OMD->getBody() && !Policy.TerseOutput) {
 Out << ' ';
-OMD->getBody()->printPretty(Out, nullptr, Policy);
+OMD->getBody()->printPretty(Out, nullptr, Policy, Indentation, "\n",
+&Context);
 }
 else if (Policy.PolishForDeclaration)
 Out << ';';
 }
 VisitDeclContext(PID, false);
 Out << "@end";
 }
 void DeclPrinter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *PID) {
-Out << "@implementation " << *PID->getClassInterface() << '(' << *PID <<")\n";
+Out << "@implementation ";
+if (const auto *CID = PID->getClassInterface())
+Out << *CID;
+else
+Out << "<<error-type>>";
+Out << '(' << *PID << ")\n";
 VisitDeclContext(PID, false);
 Out << "@end";
 // FIXME: implement the rest...
 }
 void DeclPrinter::VisitObjCCategoryDecl(ObjCCategoryDecl *PID) {
-Out << "@interface " << *PID->getClassInterface();
+Out << "@interface ";
+if (const auto *CID = PID->getClassInterface())
+Out << *CID;
+else
+Out << "<<error-type>>";
 if (auto TypeParams = PID->getTypeParamList()) {
 PrintObjCTypeParams(TypeParams);
 }
 Out << "(" << *PID << ")\n";
 if (PID->ivar_size() > 0) {
 D->printName(Out);
 }
 Out << " : ";
 D->getType().print(Out, Policy);
 Out << " : ";
-D->getCombiner()->printPretty(Out, nullptr, Policy, 0);
+D->getCombiner()->printPretty(Out, nullptr, Policy, 0, "\n", &Context);
 Out << ")";
 if (auto *Init = D->getInitializer()) {
 Out << " initializer(";
 switch (D->getInitializerKind()) {
 case OMPDeclareReductionDecl::DirectInit:
 Out << "omp_priv = ";
 break;
 case OMPDeclareReductionDecl::CallInit:
 break;
 }
-Init->printPretty(Out, nullptr, Policy, 0);
+Init->printPretty(Out, nullptr, Policy, 0, "\n", &Context);
 if (D->getInitializerKind() == OMPDeclareReductionDecl::DirectInit)
 Out << ")";
 Out << ")";
 }
 }
 }
 }
 }
 void DeclPrinter::VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D) {
-D->getInit()->printPretty(Out, nullptr, Policy, Indentation);
+D->getInit()->printPretty(Out, nullptr, Policy, Indentation, "\n", &Context);
 }
 void DeclPrinter::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *TTP) {
 if (const TypeConstraint *TC = TTP->getTypeConstraint())
 TC->print(Out, Policy);
 else
 Out << "class";
 if (TTP->isParameterPack())
 Out << " ...";
-else if (!TTP->getName().empty())
+else if (TTP->getDeclName())
 Out << ' ';
-Out << *TTP;
+if (TTP->getDeclName())
+Out << TTP->getDeclName();
 if (TTP->hasDefaultArgument()) {
 Out << " = ";
 Out << TTP->getDefaultArgument().getAsString(Policy);
 }
 Name = II->getName();
 printDeclType(NTTP->getType(), Name, NTTP->isParameterPack());
 if (NTTP->hasDefaultArgument()) {
 Out << " = ";
-NTTP->getDefaultArgument()->printPretty(Out, nullptr, Policy, Indentation);
+NTTP->getDefaultArgument()->printPretty(Out, nullptr, Policy, Indentation,
-}
+"\n", &Context);
 }
+}

Mercurial > hg > CbC > CbC_llvm

comparison clang/lib/AST/DeclPrinter.cpp @ 207:2e18cbf3894f