USRLocFinder.cpp revision 341825
1//===--- USRLocFinder.cpp - Clang refactoring library ---------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9/// 10/// \file 11/// Methods for finding all instances of a USR. Our strategy is very 12/// simple; we just compare the USR at every relevant AST node with the one 13/// provided. 14/// 15//===----------------------------------------------------------------------===// 16 17#include "clang/Tooling/Refactoring/Rename/USRLocFinder.h" 18#include "clang/AST/ASTContext.h" 19#include "clang/AST/RecursiveASTVisitor.h" 20#include "clang/Basic/LLVM.h" 21#include "clang/Basic/SourceLocation.h" 22#include "clang/Basic/SourceManager.h" 23#include "clang/Lex/Lexer.h" 24#include "clang/Tooling/Core/Lookup.h" 25#include "clang/Tooling/Refactoring/RecursiveSymbolVisitor.h" 26#include "clang/Tooling/Refactoring/Rename/SymbolName.h" 27#include "clang/Tooling/Refactoring/Rename/USRFinder.h" 28#include "llvm/ADT/StringRef.h" 29#include "llvm/Support/Casting.h" 30#include <cstddef> 31#include <set> 32#include <string> 33#include <vector> 34 35using namespace llvm; 36 37namespace clang { 38namespace tooling { 39 40namespace { 41 42// Returns true if the given Loc is valid for edit. We don't edit the 43// SourceLocations that are valid or in temporary buffer. 44bool IsValidEditLoc(const clang::SourceManager& SM, clang::SourceLocation Loc) { 45 if (Loc.isInvalid()) 46 return false; 47 const clang::FullSourceLoc FullLoc(Loc, SM); 48 std::pair<clang::FileID, unsigned> FileIdAndOffset = 49 FullLoc.getSpellingLoc().getDecomposedLoc(); 50 return SM.getFileEntryForID(FileIdAndOffset.first) != nullptr; 51} 52 53// This visitor recursively searches for all instances of a USR in a 54// translation unit and stores them for later usage. 55class USRLocFindingASTVisitor 56 : public RecursiveSymbolVisitor<USRLocFindingASTVisitor> { 57public: 58 explicit USRLocFindingASTVisitor(const std::vector<std::string> &USRs, 59 StringRef PrevName, 60 const ASTContext &Context) 61 : RecursiveSymbolVisitor(Context.getSourceManager(), 62 Context.getLangOpts()), 63 USRSet(USRs.begin(), USRs.end()), PrevName(PrevName), Context(Context) { 64 } 65 66 bool visitSymbolOccurrence(const NamedDecl *ND, 67 ArrayRef<SourceRange> NameRanges) { 68 if (USRSet.find(getUSRForDecl(ND)) != USRSet.end()) { 69 assert(NameRanges.size() == 1 && 70 "Multiple name pieces are not supported yet!"); 71 SourceLocation Loc = NameRanges[0].getBegin(); 72 const SourceManager &SM = Context.getSourceManager(); 73 // TODO: Deal with macro occurrences correctly. 74 if (Loc.isMacroID()) 75 Loc = SM.getSpellingLoc(Loc); 76 checkAndAddLocation(Loc); 77 } 78 return true; 79 } 80 81 // Non-visitors: 82 83 /// Returns a set of unique symbol occurrences. Duplicate or 84 /// overlapping occurrences are erroneous and should be reported! 85 SymbolOccurrences takeOccurrences() { return std::move(Occurrences); } 86 87private: 88 void checkAndAddLocation(SourceLocation Loc) { 89 const SourceLocation BeginLoc = Loc; 90 const SourceLocation EndLoc = Lexer::getLocForEndOfToken( 91 BeginLoc, 0, Context.getSourceManager(), Context.getLangOpts()); 92 StringRef TokenName = 93 Lexer::getSourceText(CharSourceRange::getTokenRange(BeginLoc, EndLoc), 94 Context.getSourceManager(), Context.getLangOpts()); 95 size_t Offset = TokenName.find(PrevName.getNamePieces()[0]); 96 97 // The token of the source location we find actually has the old 98 // name. 99 if (Offset != StringRef::npos) 100 Occurrences.emplace_back(PrevName, SymbolOccurrence::MatchingSymbol, 101 BeginLoc.getLocWithOffset(Offset)); 102 } 103 104 const std::set<std::string> USRSet; 105 const SymbolName PrevName; 106 SymbolOccurrences Occurrences; 107 const ASTContext &Context; 108}; 109 110SourceLocation StartLocationForType(TypeLoc TL) { 111 // For elaborated types (e.g. `struct a::A`) we want the portion after the 112 // `struct` but including the namespace qualifier, `a::`. 113 if (auto ElaboratedTypeLoc = TL.getAs<clang::ElaboratedTypeLoc>()) { 114 NestedNameSpecifierLoc NestedNameSpecifier = 115 ElaboratedTypeLoc.getQualifierLoc(); 116 if (NestedNameSpecifier.getNestedNameSpecifier()) 117 return NestedNameSpecifier.getBeginLoc(); 118 TL = TL.getNextTypeLoc(); 119 } 120 return TL.getLocStart(); 121} 122 123SourceLocation EndLocationForType(TypeLoc TL) { 124 // Dig past any namespace or keyword qualifications. 125 while (TL.getTypeLocClass() == TypeLoc::Elaborated || 126 TL.getTypeLocClass() == TypeLoc::Qualified) 127 TL = TL.getNextTypeLoc(); 128 129 // The location for template specializations (e.g. Foo<int>) includes the 130 // templated types in its location range. We want to restrict this to just 131 // before the `<` character. 132 if (TL.getTypeLocClass() == TypeLoc::TemplateSpecialization) { 133 return TL.castAs<TemplateSpecializationTypeLoc>() 134 .getLAngleLoc() 135 .getLocWithOffset(-1); 136 } 137 return TL.getEndLoc(); 138} 139 140NestedNameSpecifier *GetNestedNameForType(TypeLoc TL) { 141 // Dig past any keyword qualifications. 142 while (TL.getTypeLocClass() == TypeLoc::Qualified) 143 TL = TL.getNextTypeLoc(); 144 145 // For elaborated types (e.g. `struct a::A`) we want the portion after the 146 // `struct` but including the namespace qualifier, `a::`. 147 if (auto ElaboratedTypeLoc = TL.getAs<clang::ElaboratedTypeLoc>()) 148 return ElaboratedTypeLoc.getQualifierLoc().getNestedNameSpecifier(); 149 return nullptr; 150} 151 152// Find all locations identified by the given USRs for rename. 153// 154// This class will traverse the AST and find every AST node whose USR is in the 155// given USRs' set. 156class RenameLocFinder : public RecursiveASTVisitor<RenameLocFinder> { 157public: 158 RenameLocFinder(llvm::ArrayRef<std::string> USRs, ASTContext &Context) 159 : USRSet(USRs.begin(), USRs.end()), Context(Context) {} 160 161 // A structure records all information of a symbol reference being renamed. 162 // We try to add as few prefix qualifiers as possible. 163 struct RenameInfo { 164 // The begin location of a symbol being renamed. 165 SourceLocation Begin; 166 // The end location of a symbol being renamed. 167 SourceLocation End; 168 // The declaration of a symbol being renamed (can be nullptr). 169 const NamedDecl *FromDecl; 170 // The declaration in which the nested name is contained (can be nullptr). 171 const Decl *Context; 172 // The nested name being replaced (can be nullptr). 173 const NestedNameSpecifier *Specifier; 174 // Determine whether the prefix qualifiers of the NewName should be ignored. 175 // Normally, we set it to true for the symbol declaration and definition to 176 // avoid adding prefix qualifiers. 177 // For example, if it is true and NewName is "a::b::foo", then the symbol 178 // occurrence which the RenameInfo points to will be renamed to "foo". 179 bool IgnorePrefixQualifers; 180 }; 181 182 bool VisitNamedDecl(const NamedDecl *Decl) { 183 // UsingDecl has been handled in other place. 184 if (llvm::isa<UsingDecl>(Decl)) 185 return true; 186 187 // DestructorDecl has been handled in Typeloc. 188 if (llvm::isa<CXXDestructorDecl>(Decl)) 189 return true; 190 191 if (Decl->isImplicit()) 192 return true; 193 194 if (isInUSRSet(Decl)) { 195 // For the case of renaming an alias template, we actually rename the 196 // underlying alias declaration of the template. 197 if (const auto* TAT = dyn_cast<TypeAliasTemplateDecl>(Decl)) 198 Decl = TAT->getTemplatedDecl(); 199 200 auto StartLoc = Decl->getLocation(); 201 auto EndLoc = StartLoc; 202 if (IsValidEditLoc(Context.getSourceManager(), StartLoc)) { 203 RenameInfo Info = {StartLoc, 204 EndLoc, 205 /*FromDecl=*/nullptr, 206 /*Context=*/nullptr, 207 /*Specifier=*/nullptr, 208 /*IgnorePrefixQualifers=*/true}; 209 RenameInfos.push_back(Info); 210 } 211 } 212 return true; 213 } 214 215 bool VisitMemberExpr(const MemberExpr *Expr) { 216 const NamedDecl *Decl = Expr->getFoundDecl(); 217 auto StartLoc = Expr->getMemberLoc(); 218 auto EndLoc = Expr->getMemberLoc(); 219 if (isInUSRSet(Decl)) { 220 RenameInfos.push_back({StartLoc, EndLoc, 221 /*FromDecl=*/nullptr, 222 /*Context=*/nullptr, 223 /*Specifier=*/nullptr, 224 /*IgnorePrefixQualifiers=*/true}); 225 } 226 return true; 227 } 228 229 bool VisitCXXConstructorDecl(const CXXConstructorDecl *CD) { 230 // Fix the constructor initializer when renaming class members. 231 for (const auto *Initializer : CD->inits()) { 232 // Ignore implicit initializers. 233 if (!Initializer->isWritten()) 234 continue; 235 236 if (const FieldDecl *FD = Initializer->getMember()) { 237 if (isInUSRSet(FD)) { 238 auto Loc = Initializer->getSourceLocation(); 239 RenameInfos.push_back({Loc, Loc, 240 /*FromDecl=*/nullptr, 241 /*Context=*/nullptr, 242 /*Specifier=*/nullptr, 243 /*IgnorePrefixQualifiers=*/true}); 244 } 245 } 246 } 247 return true; 248 } 249 250 bool VisitDeclRefExpr(const DeclRefExpr *Expr) { 251 const NamedDecl *Decl = Expr->getFoundDecl(); 252 // Get the underlying declaration of the shadow declaration introduced by a 253 // using declaration. 254 if (auto *UsingShadow = llvm::dyn_cast<UsingShadowDecl>(Decl)) { 255 Decl = UsingShadow->getTargetDecl(); 256 } 257 258 auto StartLoc = Expr->getLocStart(); 259 // For template function call expressions like `foo<int>()`, we want to 260 // restrict the end of location to just before the `<` character. 261 SourceLocation EndLoc = Expr->hasExplicitTemplateArgs() 262 ? Expr->getLAngleLoc().getLocWithOffset(-1) 263 : Expr->getLocEnd(); 264 265 if (const auto *MD = llvm::dyn_cast<CXXMethodDecl>(Decl)) { 266 if (isInUSRSet(MD)) { 267 // Handle renaming static template class methods, we only rename the 268 // name without prefix qualifiers and restrict the source range to the 269 // name. 270 RenameInfos.push_back({EndLoc, EndLoc, 271 /*FromDecl=*/nullptr, 272 /*Context=*/nullptr, 273 /*Specifier=*/nullptr, 274 /*IgnorePrefixQualifiers=*/true}); 275 return true; 276 } 277 } 278 279 // In case of renaming an enum declaration, we have to explicitly handle 280 // unscoped enum constants referenced in expressions (e.g. 281 // "auto r = ns1::ns2::Green" where Green is an enum constant of an unscoped 282 // enum decl "ns1::ns2::Color") as these enum constants cannot be caught by 283 // TypeLoc. 284 if (const auto *T = llvm::dyn_cast<EnumConstantDecl>(Decl)) { 285 // FIXME: Handle the enum constant without prefix qualifiers (`a = Green`) 286 // when renaming an unscoped enum declaration with a new namespace. 287 if (!Expr->hasQualifier()) 288 return true; 289 290 if (const auto *ED = 291 llvm::dyn_cast_or_null<EnumDecl>(getClosestAncestorDecl(*T))) { 292 if (ED->isScoped()) 293 return true; 294 Decl = ED; 295 } 296 // The current fix would qualify "ns1::ns2::Green" as 297 // "ns1::ns2::Color::Green". 298 // 299 // Get the EndLoc of the replacement by moving 1 character backward ( 300 // to exclude the last '::'). 301 // 302 // ns1::ns2::Green; 303 // ^ ^^ 304 // BeginLoc |EndLoc of the qualifier 305 // new EndLoc 306 EndLoc = Expr->getQualifierLoc().getEndLoc().getLocWithOffset(-1); 307 assert(EndLoc.isValid() && 308 "The enum constant should have prefix qualifers."); 309 } 310 if (isInUSRSet(Decl) && 311 IsValidEditLoc(Context.getSourceManager(), StartLoc)) { 312 RenameInfo Info = {StartLoc, 313 EndLoc, 314 Decl, 315 getClosestAncestorDecl(*Expr), 316 Expr->getQualifier(), 317 /*IgnorePrefixQualifers=*/false}; 318 RenameInfos.push_back(Info); 319 } 320 321 return true; 322 } 323 324 bool VisitUsingDecl(const UsingDecl *Using) { 325 for (const auto *UsingShadow : Using->shadows()) { 326 if (isInUSRSet(UsingShadow->getTargetDecl())) { 327 UsingDecls.push_back(Using); 328 break; 329 } 330 } 331 return true; 332 } 333 334 bool VisitNestedNameSpecifierLocations(NestedNameSpecifierLoc NestedLoc) { 335 if (!NestedLoc.getNestedNameSpecifier()->getAsType()) 336 return true; 337 338 if (const auto *TargetDecl = 339 getSupportedDeclFromTypeLoc(NestedLoc.getTypeLoc())) { 340 if (isInUSRSet(TargetDecl)) { 341 RenameInfo Info = {NestedLoc.getBeginLoc(), 342 EndLocationForType(NestedLoc.getTypeLoc()), 343 TargetDecl, 344 getClosestAncestorDecl(NestedLoc), 345 NestedLoc.getNestedNameSpecifier()->getPrefix(), 346 /*IgnorePrefixQualifers=*/false}; 347 RenameInfos.push_back(Info); 348 } 349 } 350 return true; 351 } 352 353 bool VisitTypeLoc(TypeLoc Loc) { 354 auto Parents = Context.getParents(Loc); 355 TypeLoc ParentTypeLoc; 356 if (!Parents.empty()) { 357 // Handle cases of nested name specificier locations. 358 // 359 // The VisitNestedNameSpecifierLoc interface is not impelmented in 360 // RecursiveASTVisitor, we have to handle it explicitly. 361 if (const auto *NSL = Parents[0].get<NestedNameSpecifierLoc>()) { 362 VisitNestedNameSpecifierLocations(*NSL); 363 return true; 364 } 365 366 if (const auto *TL = Parents[0].get<TypeLoc>()) 367 ParentTypeLoc = *TL; 368 } 369 370 // Handle the outermost TypeLoc which is directly linked to the interesting 371 // declaration and don't handle nested name specifier locations. 372 if (const auto *TargetDecl = getSupportedDeclFromTypeLoc(Loc)) { 373 if (isInUSRSet(TargetDecl)) { 374 // Only handle the outermost typeLoc. 375 // 376 // For a type like "a::Foo", there will be two typeLocs for it. 377 // One ElaboratedType, the other is RecordType: 378 // 379 // ElaboratedType 0x33b9390 'a::Foo' sugar 380 // `-RecordType 0x338fef0 'class a::Foo' 381 // `-CXXRecord 0x338fe58 'Foo' 382 // 383 // Skip if this is an inner typeLoc. 384 if (!ParentTypeLoc.isNull() && 385 isInUSRSet(getSupportedDeclFromTypeLoc(ParentTypeLoc))) 386 return true; 387 388 auto StartLoc = StartLocationForType(Loc); 389 auto EndLoc = EndLocationForType(Loc); 390 if (IsValidEditLoc(Context.getSourceManager(), StartLoc)) { 391 RenameInfo Info = {StartLoc, 392 EndLoc, 393 TargetDecl, 394 getClosestAncestorDecl(Loc), 395 GetNestedNameForType(Loc), 396 /*IgnorePrefixQualifers=*/false}; 397 RenameInfos.push_back(Info); 398 } 399 return true; 400 } 401 } 402 403 // Handle specific template class specialiation cases. 404 if (const auto *TemplateSpecType = 405 dyn_cast<TemplateSpecializationType>(Loc.getType())) { 406 TypeLoc TargetLoc = Loc; 407 if (!ParentTypeLoc.isNull()) { 408 if (llvm::isa<ElaboratedType>(ParentTypeLoc.getType())) 409 TargetLoc = ParentTypeLoc; 410 } 411 412 if (isInUSRSet(TemplateSpecType->getTemplateName().getAsTemplateDecl())) { 413 TypeLoc TargetLoc = Loc; 414 // FIXME: Find a better way to handle this case. 415 // For the qualified template class specification type like 416 // "ns::Foo<int>" in "ns::Foo<int>& f();", we want the parent typeLoc 417 // (ElaboratedType) of the TemplateSpecializationType in order to 418 // catch the prefix qualifiers "ns::". 419 if (!ParentTypeLoc.isNull() && 420 llvm::isa<ElaboratedType>(ParentTypeLoc.getType())) 421 TargetLoc = ParentTypeLoc; 422 423 auto StartLoc = StartLocationForType(TargetLoc); 424 auto EndLoc = EndLocationForType(TargetLoc); 425 if (IsValidEditLoc(Context.getSourceManager(), StartLoc)) { 426 RenameInfo Info = { 427 StartLoc, 428 EndLoc, 429 TemplateSpecType->getTemplateName().getAsTemplateDecl(), 430 getClosestAncestorDecl( 431 ast_type_traits::DynTypedNode::create(TargetLoc)), 432 GetNestedNameForType(TargetLoc), 433 /*IgnorePrefixQualifers=*/false}; 434 RenameInfos.push_back(Info); 435 } 436 } 437 } 438 return true; 439 } 440 441 // Returns a list of RenameInfo. 442 const std::vector<RenameInfo> &getRenameInfos() const { return RenameInfos; } 443 444 // Returns a list of using declarations which are needed to update. 445 const std::vector<const UsingDecl *> &getUsingDecls() const { 446 return UsingDecls; 447 } 448 449private: 450 // Get the supported declaration from a given typeLoc. If the declaration type 451 // is not supported, returns nullptr. 452 const NamedDecl *getSupportedDeclFromTypeLoc(TypeLoc Loc) { 453 if (const auto* TT = Loc.getType()->getAs<clang::TypedefType>()) 454 return TT->getDecl(); 455 if (const auto *RD = Loc.getType()->getAsCXXRecordDecl()) 456 return RD; 457 if (const auto *ED = 458 llvm::dyn_cast_or_null<EnumDecl>(Loc.getType()->getAsTagDecl())) 459 return ED; 460 return nullptr; 461 } 462 463 // Get the closest ancester which is a declaration of a given AST node. 464 template <typename ASTNodeType> 465 const Decl *getClosestAncestorDecl(const ASTNodeType &Node) { 466 auto Parents = Context.getParents(Node); 467 // FIXME: figure out how to handle it when there are multiple parents. 468 if (Parents.size() != 1) 469 return nullptr; 470 if (ast_type_traits::ASTNodeKind::getFromNodeKind<Decl>().isBaseOf( 471 Parents[0].getNodeKind())) 472 return Parents[0].template get<Decl>(); 473 return getClosestAncestorDecl(Parents[0]); 474 } 475 476 // Get the parent typeLoc of a given typeLoc. If there is no such parent, 477 // return nullptr. 478 const TypeLoc *getParentTypeLoc(TypeLoc Loc) const { 479 auto Parents = Context.getParents(Loc); 480 // FIXME: figure out how to handle it when there are multiple parents. 481 if (Parents.size() != 1) 482 return nullptr; 483 return Parents[0].get<TypeLoc>(); 484 } 485 486 // Check whether the USR of a given Decl is in the USRSet. 487 bool isInUSRSet(const Decl *Decl) const { 488 auto USR = getUSRForDecl(Decl); 489 if (USR.empty()) 490 return false; 491 return llvm::is_contained(USRSet, USR); 492 } 493 494 const std::set<std::string> USRSet; 495 ASTContext &Context; 496 std::vector<RenameInfo> RenameInfos; 497 // Record all interested using declarations which contains the using-shadow 498 // declarations of the symbol declarations being renamed. 499 std::vector<const UsingDecl *> UsingDecls; 500}; 501 502} // namespace 503 504SymbolOccurrences getOccurrencesOfUSRs(ArrayRef<std::string> USRs, 505 StringRef PrevName, Decl *Decl) { 506 USRLocFindingASTVisitor Visitor(USRs, PrevName, Decl->getASTContext()); 507 Visitor.TraverseDecl(Decl); 508 return Visitor.takeOccurrences(); 509} 510 511std::vector<tooling::AtomicChange> 512createRenameAtomicChanges(llvm::ArrayRef<std::string> USRs, 513 llvm::StringRef NewName, Decl *TranslationUnitDecl) { 514 RenameLocFinder Finder(USRs, TranslationUnitDecl->getASTContext()); 515 Finder.TraverseDecl(TranslationUnitDecl); 516 517 const SourceManager &SM = 518 TranslationUnitDecl->getASTContext().getSourceManager(); 519 520 std::vector<tooling::AtomicChange> AtomicChanges; 521 auto Replace = [&](SourceLocation Start, SourceLocation End, 522 llvm::StringRef Text) { 523 tooling::AtomicChange ReplaceChange = tooling::AtomicChange(SM, Start); 524 llvm::Error Err = ReplaceChange.replace( 525 SM, CharSourceRange::getTokenRange(Start, End), Text); 526 if (Err) { 527 llvm::errs() << "Failed to add replacement to AtomicChange: " 528 << llvm::toString(std::move(Err)) << "\n"; 529 return; 530 } 531 AtomicChanges.push_back(std::move(ReplaceChange)); 532 }; 533 534 for (const auto &RenameInfo : Finder.getRenameInfos()) { 535 std::string ReplacedName = NewName.str(); 536 if (RenameInfo.IgnorePrefixQualifers) { 537 // Get the name without prefix qualifiers from NewName. 538 size_t LastColonPos = NewName.find_last_of(':'); 539 if (LastColonPos != std::string::npos) 540 ReplacedName = NewName.substr(LastColonPos + 1); 541 } else { 542 if (RenameInfo.FromDecl && RenameInfo.Context) { 543 if (!llvm::isa<clang::TranslationUnitDecl>( 544 RenameInfo.Context->getDeclContext())) { 545 ReplacedName = tooling::replaceNestedName( 546 RenameInfo.Specifier, RenameInfo.Context->getDeclContext(), 547 RenameInfo.FromDecl, 548 NewName.startswith("::") ? NewName.str() 549 : ("::" + NewName).str()); 550 } else { 551 // This fixes the case where type `T` is a parameter inside a function 552 // type (e.g. `std::function<void(T)>`) and the DeclContext of `T` 553 // becomes the translation unit. As a workaround, we simply use 554 // fully-qualified name here for all references whose `DeclContext` is 555 // the translation unit and ignore the possible existence of 556 // using-decls (in the global scope) that can shorten the replaced 557 // name. 558 llvm::StringRef ActualName = Lexer::getSourceText( 559 CharSourceRange::getTokenRange( 560 SourceRange(RenameInfo.Begin, RenameInfo.End)), 561 SM, TranslationUnitDecl->getASTContext().getLangOpts()); 562 // Add the leading "::" back if the name written in the code contains 563 // it. 564 if (ActualName.startswith("::") && !NewName.startswith("::")) { 565 ReplacedName = "::" + NewName.str(); 566 } 567 } 568 } 569 // If the NewName contains leading "::", add it back. 570 if (NewName.startswith("::") && NewName.substr(2) == ReplacedName) 571 ReplacedName = NewName.str(); 572 } 573 Replace(RenameInfo.Begin, RenameInfo.End, ReplacedName); 574 } 575 576 // Hanlde using declarations explicitly as "using a::Foo" don't trigger 577 // typeLoc for "a::Foo". 578 for (const auto *Using : Finder.getUsingDecls()) 579 Replace(Using->getLocStart(), Using->getLocEnd(), "using " + NewName.str()); 580 581 return AtomicChanges; 582} 583 584} // end namespace tooling 585} // end namespace clang 586