+12 -3

src/applications/calendar/parser/data/PhutilCalendarEventNode.php

reviewed

··· 116 116 return $this->organizer; 117 117 } 118 118 119 119 + /** 120 120 + * @param array<PhutilCalendarUserNode> $attendees 121 121 + */ 119 122 public function setAttendees(array $attendees) { 120 120 - assert_instances_of($attendees, 'PhutilCalendarUserNode'); 123 123 + assert_instances_of($attendees, PhutilCalendarUserNode::class); 121 124 $this->attendees = $attendees; 122 125 return $this; 123 126 } ··· 159 162 return $this->recurrenceRule; 160 163 } 161 164 165 165 + /** 166 166 + * @param array<PhutilCalendarDateTime> $recurrence_exceptions 167 167 + */ 162 168 public function setRecurrenceExceptions(array $recurrence_exceptions) { 163 163 - assert_instances_of($recurrence_exceptions, 'PhutilCalendarDateTime'); 169 169 + assert_instances_of($recurrence_exceptions, PhutilCalendarDateTime::class); 164 170 $this->recurrenceExceptions = $recurrence_exceptions; 165 171 return $this; 166 172 } ··· 169 175 return $this->recurrenceExceptions; 170 176 } 171 177 178 178 + /** 179 179 + * @param array<PhutilCalendarDateTime> $recurrence_dates 180 180 + */ 172 181 public function setRecurrenceDates(array $recurrence_dates) { 173 173 - assert_instances_of($recurrence_dates, 'PhutilCalendarDateTime'); 182 182 + assert_instances_of($recurrence_dates, PhutilCalendarDateTime::class); 174 183 $this->recurrenceDates = $recurrence_dates; 175 184 return $this; 176 185 }

+4 -1

src/applications/calendar/parser/data/PhutilCalendarRecurrenceList.php

reviewed

··· 6 6 private $dates = array(); 7 7 private $order; 8 8 9 9 + /** 10 10 + * @param array<PhutilCalendarDateTime> $dates 11 11 + */ 9 12 public function setDates(array $dates) { 10 10 - assert_instances_of($dates, 'PhutilCalendarDateTime'); 13 13 + assert_instances_of($dates, PhutilCalendarDateTime::class); 11 14 $this->dates = $dates; 12 15 return $this; 13 16 }

+6 -1

src/applications/calendar/parser/ics/PhutilICSWriter.php

reviewed

··· 285 285 return $this->newDateTimesProperty($name, array($value), $parameters); 286 286 } 287 287 288 288 + /** 289 289 + * @param $name 290 290 + * @param array<PhutilCalendarDateTime> $values 291 291 + * @param array $parameters 292 292 + */ 288 293 private function newDateTimesProperty( 289 294 $name, 290 295 array $values, 291 296 array $parameters = array()) { 292 292 - assert_instances_of($values, 'PhutilCalendarDateTime'); 297 297 + assert_instances_of($values, PhutilCalendarDateTime::class); 293 298 294 299 if (head($values)->getIsAllDay()) { 295 300 $parameters[] = array(

+10 -2

src/applications/calendar/query/PhabricatorCalendarEventSearchEngine.php

reviewed

··· 286 286 return $result; 287 287 } 288 288 289 289 + /** 290 290 + * @param array<PhabricatorCalendarEvent> $events 291 291 + * @param PhabricatorSavedQuery $query 292 292 + */ 289 293 private function buildCalendarListView( 290 294 array $events, 291 295 PhabricatorSavedQuery $query) { 292 296 293 293 - assert_instances_of($events, 'PhabricatorCalendarEvent'); 297 297 + assert_instances_of($events, PhabricatorCalendarEvent::class); 294 298 $viewer = $this->requireViewer(); 295 299 $list = new PHUIObjectItemListView(); 296 300 ··· 335 339 ->setNoDataString(pht('No events found.')); 336 340 } 337 341 342 342 + /** 343 343 + * @param array<PhabricatorCalendarEvent> $events 344 344 + * @param PhabricatorSavedQuery $query 345 345 + */ 338 346 private function buildCalendarMonthView( 339 347 array $events, 340 348 PhabricatorSavedQuery $query) { 341 341 - assert_instances_of($events, 'PhabricatorCalendarEvent'); 349 349 + assert_instances_of($events, PhabricatorCalendarEvent::class); 342 350 343 351 $viewer = $this->requireViewer(); 344 352 $now = PhabricatorTime::getNow();

+6 -1

src/applications/calendar/query/PhabricatorCalendarExportSearchEngine.php

reviewed

··· 56 56 return parent::buildSavedQueryFromBuiltin($query_key); 57 57 } 58 58 59 59 + /** 60 60 + * @param array<PhabricatorCalendarExport> $exports 61 61 + * @param PhabricatorSavedQuery $query 62 62 + * @param array<PhabricatorObjectHandle> $handles 63 63 + */ 59 64 protected function renderResultList( 60 65 array $exports, 61 66 PhabricatorSavedQuery $query, 62 67 array $handles) { 63 68 64 64 - assert_instances_of($exports, 'PhabricatorCalendarExport'); 69 69 + assert_instances_of($exports, PhabricatorCalendarExport::class); 65 70 $viewer = $this->requireViewer(); 66 71 67 72 $list = new PHUIObjectItemListView();

+6 -1

src/applications/calendar/query/PhabricatorCalendarImportLogSearchEngine.php

reviewed

··· 62 62 return parent::buildSavedQueryFromBuiltin($query_key); 63 63 } 64 64 65 65 + /** 66 66 + * @param array<PhabricatorCalendarImportLog> $logs 67 67 + * @param PhabricatorSavedQuery $query 68 68 + * @param array<PhabricatorObjectHandle> $handles 69 69 + */ 65 70 protected function renderResultList( 66 71 array $logs, 67 72 PhabricatorSavedQuery $query, 68 73 array $handles) { 69 74 70 70 - assert_instances_of($logs, 'PhabricatorCalendarImportLog'); 75 75 + assert_instances_of($logs, PhabricatorCalendarImportLog::class); 71 76 $viewer = $this->requireViewer(); 72 77 73 78 $view = id(new PhabricatorCalendarImportLogView())

+6 -1

src/applications/calendar/query/PhabricatorCalendarImportSearchEngine.php

reviewed

··· 53 53 return parent::buildSavedQueryFromBuiltin($query_key); 54 54 } 55 55 56 56 + /** 57 57 + * @param array<PhabricatorCalendarImport> $imports 58 58 + * @param PhabricatorSavedQuery $query 59 59 + * @param array<PhabricatorObjectHandle> $handles 60 60 + */ 56 61 protected function renderResultList( 57 62 array $imports, 58 63 PhabricatorSavedQuery $query, 59 64 array $handles) { 60 65 61 61 - assert_instances_of($imports, 'PhabricatorCalendarImport'); 66 66 + assert_instances_of($imports, PhabricatorCalendarImport::class); 62 67 $viewer = $this->requireViewer(); 63 68 64 69 $list = new PHUIObjectItemListView();

+4 -1

src/applications/calendar/util/PhabricatorCalendarICSWriter.php

reviewed

··· 14 14 return $this->viewer; 15 15 } 16 16 17 17 + /** 18 18 + * @param array<PhabricatorCalendarEvent> $events 19 19 + */ 17 20 public function setEvents(array $events) { 18 18 - assert_instances_of($events, 'PhabricatorCalendarEvent'); 21 21 + assert_instances_of($events, PhabricatorCalendarEvent::class); 19 22 $this->events = $events; 20 23 return $this; 21 24 }

+4 -1

src/applications/calendar/view/PhabricatorCalendarImportLogView.php

reviewed

··· 5 5 private $logs = array(); 6 6 private $showImportSources = false; 7 7 8 8 + /** 9 9 + * @param array<PhabricatorCalendarImportLog> $logs 10 10 + */ 8 11 public function setLogs(array $logs) { 9 9 - assert_instances_of($logs, 'PhabricatorCalendarImportLog'); 12 12 + assert_instances_of($logs, PhabricatorCalendarImportLog::class); 10 13 $this->logs = $logs; 11 14 return $this; 12 15 }

+5 -1

src/applications/differential/conduit/DifferentialConduitAPIMethod.php

reviewed

··· 118 118 ->execute(); 119 119 } 120 120 121 121 + /** 122 122 + * @param PhabricatorUser $viewer 123 123 + * @param array<DifferentialRevision> $revisions 124 124 + */ 121 125 protected function loadCustomFieldsForRevisions( 122 126 PhabricatorUser $viewer, 123 127 array $revisions) { 124 124 - assert_instances_of($revisions, 'DifferentialRevision'); 128 128 + assert_instances_of($revisions, DifferentialRevision::class); 125 129 126 130 if (!$revisions) { 127 131 return array();

+4 -1

src/applications/differential/controller/DifferentialController.php

reviewed

··· 25 25 return $this->buildSideNavView(true)->getMenu(); 26 26 } 27 27 28 28 + /** 29 29 + * @param array<DifferentialChangeset> $changesets 30 30 + */ 28 31 protected function buildPackageMaps(array $changesets) { 29 29 - assert_instances_of($changesets, 'DifferentialChangeset'); 32 32 + assert_instances_of($changesets, DifferentialChangeset::class); 30 33 31 34 $this->packageChangesetMap = array(); 32 35 $this->pathPackageMap = array();

+38 -9

src/applications/differential/controller/DifferentialRevisionViewController.php

reviewed

··· 861 861 return $curtain; 862 862 } 863 863 864 864 + /** 865 865 + * @param array<DifferentialDiff> $diffs 866 866 + */ 864 867 private function loadHistoryDiffStatus(array $diffs) { 865 865 - assert_instances_of($diffs, 'DifferentialDiff'); 868 868 + assert_instances_of($diffs, DifferentialDiff::class); 866 869 867 870 $diff_phids = mpull($diffs, 'getPHID'); 868 871 $bad_unit_status = array( ··· 978 981 return array($changesets, $vs_map, $vs_changesets, $refs); 979 982 } 980 983 984 984 + /** 985 985 + * @param PhabricatorRepository $repository 986 986 + * @param array<DifferentialChangeset> $unfolded_changesets 987 987 + */ 981 988 private function buildSymbolIndexes( 982 989 PhabricatorRepository $repository, 983 990 array $unfolded_changesets) { 984 984 - assert_instances_of($unfolded_changesets, 'DifferentialChangeset'); 991 991 + assert_instances_of($unfolded_changesets, DifferentialChangeset::class); 985 992 986 993 $engine = PhabricatorSyntaxHighlighter::newEngine(); 987 994 ··· 1019 1026 return $symbol_indexes; 1020 1027 } 1021 1028 1029 1029 + /** 1030 1030 + * @param array<DifferentialChangeset> $changesets 1031 1031 + * @param DifferentialDiff $target 1032 1032 + * @param PhabricatorRepository $repository 1033 1033 + */ 1022 1034 private function loadOtherRevisions( 1023 1035 array $changesets, 1024 1036 DifferentialDiff $target, 1025 1037 PhabricatorRepository $repository) { 1026 1026 - assert_instances_of($changesets, 'DifferentialChangeset'); 1038 1038 + assert_instances_of($changesets, DifferentialChangeset::class); 1027 1039 1028 1040 $viewer = $this->getViewer(); 1029 1041 ··· 1068 1080 return $results; 1069 1081 } 1070 1082 1083 1083 + /** 1084 1084 + * @param array<DifferentialRevision> $revisions 1085 1085 + */ 1071 1086 private function renderOtherRevisions(array $revisions) { 1072 1072 - assert_instances_of($revisions, 'DifferentialRevision'); 1087 1087 + assert_instances_of($revisions, DifferentialRevision::class); 1073 1088 $viewer = $this->getViewer(); 1074 1089 1075 1090 $header = id(new PHUIHeaderView()) ··· 1082 1097 ->setNoBox(true); 1083 1098 } 1084 1099 1085 1085 - 1100 1100 + /** 1101 1101 + * @param DifferentialRevision $revision 1102 1102 + * @param array<DifferentialChangeset> $changesets 1103 1103 + * @param array<DifferentialChangeset> $vs_changesets 1104 1104 + * @param array $vs_map 1105 1105 + * @param ?PhabricatorRepository $repository 1106 1106 + */ 1086 1107 private function buildRawDiffResponse( 1087 1108 DifferentialRevision $revision, 1088 1109 array $changesets, ··· 1090 1111 array $vs_map, 1091 1112 ?PhabricatorRepository $repository = null) { 1092 1113 1093 1093 - assert_instances_of($changesets, 'DifferentialChangeset'); 1094 1094 - assert_instances_of($vs_changesets, 'DifferentialChangeset'); 1114 1114 + assert_instances_of($changesets, DifferentialChangeset::class); 1115 1115 + assert_instances_of($vs_changesets, DifferentialChangeset::class); 1095 1116 1096 1117 $viewer = $this->getViewer(); 1097 1118 ··· 1350 1371 ->setShowViewAll(true); 1351 1372 } 1352 1373 1374 1374 + /** 1375 1375 + * @param DifferentialRevision $revision 1376 1376 + * @param array<DifferentialDiff> $diffs 1377 1377 + */ 1353 1378 private function getOldDiffID(DifferentialRevision $revision, array $diffs) { 1354 1354 - assert_instances_of($diffs, 'DifferentialDiff'); 1379 1379 + assert_instances_of($diffs, DifferentialDiff::class); 1355 1380 $request = $this->getRequest(); 1356 1381 1357 1382 $diffs = mpull($diffs, null, 'getID'); ··· 1459 1484 return null; 1460 1485 } 1461 1486 1487 1487 + /** 1488 1488 + * @param DifferentialRevision $revision 1489 1489 + * @param array<DifferentialDiff> $diffs 1490 1490 + */ 1462 1491 private function getNewDiffID(DifferentialRevision $revision, array $diffs) { 1463 1463 - assert_instances_of($diffs, 'DifferentialDiff'); 1492 1492 + assert_instances_of($diffs, DifferentialDiff::class); 1464 1493 $request = $this->getRequest(); 1465 1494 1466 1495 $diffs = mpull($diffs, null, 'getID');

+4 -1

src/applications/differential/engine/DifferentialChangesetEngine.php

reviewed

··· 13 13 return $this->viewer; 14 14 } 15 15 16 16 + /** 17 17 + * @param array<DifferentialChangeset> $changesets 18 18 + */ 16 19 public function rebuildChangesets(array $changesets) { 17 17 - assert_instances_of($changesets, 'DifferentialChangeset'); 20 20 + assert_instances_of($changesets, DifferentialChangeset::class); 18 21 19 22 $changesets = $this->loadChangesetFiles($changesets); 20 23

+4 -1

src/applications/differential/parser/DifferentialChangesetParser.php

reviewed

··· 334 334 return $this; 335 335 } 336 336 337 337 + /** 338 338 + * @param array<PhabricatorObjectHandle> $handles 339 339 + */ 337 340 public function setHandles(array $handles) { 338 338 - assert_instances_of($handles, 'PhabricatorObjectHandle'); 341 341 + assert_instances_of($handles, PhabricatorObjectHandle::class); 339 342 $this->handles = $handles; 340 343 return $this; 341 344 }

+2 -1

src/applications/differential/parser/DifferentialCommitMessageParser.php

reviewed

··· 65 65 66 66 67 67 /** 68 68 + * @param array<DifferentialCommitMessageField> $fields 68 69 * @task config 69 70 */ 70 71 public function setCommitMessageFields(array $fields) { 71 71 - assert_instances_of($fields, 'DifferentialCommitMessageField'); 72 72 + assert_instances_of($fields, DifferentialCommitMessageField::class); 72 73 $fields = mpull($fields, null, 'getCommitMessageFieldKey'); 73 74 $this->commitMessageFields = $fields; 74 75 return $this;

+26 -7

src/applications/differential/parser/DifferentialHunkParser.php

reviewed

··· 14 14 * datastructure is used to determine when to render "Context not available." 15 15 * in diffs with multiple hunks. 16 16 * 17 17 + * @param array<DifferentialHunk> $hunks 17 18 * @return array<int|string, bool> Map of lines where hunks start, other than 18 19 * line 1. 19 20 */ 20 21 public function getHunkStartLines(array $hunks) { 21 21 - assert_instances_of($hunks, 'DifferentialHunk'); 22 22 + assert_instances_of($hunks, DifferentialHunk::class); 22 23 23 24 $map = array(); 24 25 foreach ($hunks as $hunk) { ··· 475 476 return $corpus; 476 477 } 477 478 479 479 + /** 480 480 + * @param array<DifferentialHunk> $hunks 481 481 + */ 478 482 public function parseHunksForLineData(array $hunks) { 479 479 - assert_instances_of($hunks, 'DifferentialHunk'); 483 483 + assert_instances_of($hunks, DifferentialHunk::class); 480 484 481 485 $old_lines = array(); 482 486 $new_lines = array(); ··· 564 568 return $this; 565 569 } 566 570 571 571 + /** 572 572 + * @param array<DifferentialHunk> $changeset_hunks 573 573 + * @param array<DifferentialHunk> $old_hunks 574 574 + * @param array<DifferentialHunk> $new_hunks 575 575 + */ 567 576 public function parseHunksForHighlightMasks( 568 577 array $changeset_hunks, 569 578 array $old_hunks, 570 579 array $new_hunks) { 571 571 - assert_instances_of($changeset_hunks, 'DifferentialHunk'); 572 572 - assert_instances_of($old_hunks, 'DifferentialHunk'); 573 573 - assert_instances_of($new_hunks, 'DifferentialHunk'); 580 580 + assert_instances_of($changeset_hunks, DifferentialHunk::class); 581 581 + assert_instances_of($old_hunks, DifferentialHunk::class); 582 582 + assert_instances_of($new_hunks, DifferentialHunk::class); 574 583 575 584 // Put changes side by side. 576 585 $olds = array(); ··· 663 672 return array($highlight_old, $highlight_new); 664 673 } 665 674 675 675 + /** 676 676 + * @param array<DifferentialHunk> $new_hunks 677 677 + * @param bool $is_new 678 678 + * @param int $line_number 679 679 + * @param int $line_length 680 680 + * @param int $add_context 681 681 + */ 666 682 public function makeContextDiff( 667 683 array $hunks, 668 684 $is_new, ··· 670 686 $line_length, 671 687 $add_context) { 672 688 673 673 - assert_instances_of($hunks, 'DifferentialHunk'); 689 689 + assert_instances_of($hunks, DifferentialHunk::class); 674 690 675 691 $context = array(); 676 692 ··· 749 765 return implode("\n", $context); 750 766 } 751 767 768 768 + /** 769 769 + * @param array<DifferentialHunk> $new_hunks 770 770 + */ 752 771 private function computeOffsets(array $hunks) { 753 753 - assert_instances_of($hunks, 'DifferentialHunk'); 772 772 + assert_instances_of($hunks, DifferentialHunk::class); 754 773 755 774 $offsets = array(); 756 775 $n = 1;

+4 -1

src/applications/differential/parser/DifferentialLineAdjustmentMap.php

reviewed

··· 158 158 return $this; 159 159 } 160 160 161 161 + /** 162 162 + * @param array<DifferentialHunk> $hunks 163 163 + */ 161 164 public static function newFromHunks(array $hunks) { 162 162 - assert_instances_of($hunks, 'DifferentialHunk'); 165 165 + assert_instances_of($hunks, DifferentialHunk::class); 163 166 164 167 $map = array(); 165 168 $o = 0;

+4 -1

src/applications/differential/query/DifferentialChangesetQuery.php

reviewed

··· 25 25 return $this; 26 26 } 27 27 28 28 + /** 29 29 + * @param array<DifferentialDiff> $diffs 30 30 + */ 28 31 public function withDiffs(array $diffs) { 29 29 - assert_instances_of($diffs, 'DifferentialDiff'); 32 32 + assert_instances_of($diffs, DifferentialDiff::class); 30 33 $this->diffs = $diffs; 31 34 return $this; 32 35 }

+6 -1

src/applications/differential/query/DifferentialChangesetSearchEngine.php

reviewed

··· 86 86 return parent::buildSavedQueryFromBuiltin($query_key); 87 87 } 88 88 89 89 + /** 90 90 + * @param array<DifferentialChangeset> $changesets 91 91 + * @param PhabricatorSavedQuery $query 92 92 + * @param array<PhabricatorObjectHandle> $handles 93 93 + */ 89 94 protected function renderResultList( 90 95 array $changesets, 91 96 PhabricatorSavedQuery $query, 92 97 array $handles) { 93 98 94 94 - assert_instances_of($changesets, 'DifferentialChangeset'); 99 99 + assert_instances_of($changesets, DifferentialChangeset::class); 95 100 $viewer = $this->requireViewer(); 96 101 97 102 $rows = array();

+6 -1

src/applications/differential/query/DifferentialDiffSearchEngine.php

reviewed

··· 62 62 return parent::buildSavedQueryFromBuiltin($query_key); 63 63 } 64 64 65 65 + /** 66 66 + * @param array<DifferentialDiff> $revisions 67 67 + * @param PhabricatorSavedQuery $query 68 68 + * @param array<PhabricatorObjectHandle> $handles 69 69 + */ 65 70 protected function renderResultList( 66 71 array $revisions, 67 72 PhabricatorSavedQuery $query, 68 73 array $handles) { 69 69 - assert_instances_of($revisions, 'DifferentialDiff'); 74 74 + assert_instances_of($revisions, DifferentialDiff::class); 70 75 71 76 $viewer = $this->requireViewer(); 72 77

+4 -1

src/applications/differential/query/DifferentialHunkQuery.php

reviewed

··· 9 9 private $changesets; 10 10 private $shouldAttachToChangesets; 11 11 12 12 + /** 13 13 + * @param array<DifferentialChangeset> $changesets 14 14 + */ 12 15 public function withChangesets(array $changesets) { 13 13 - assert_instances_of($changesets, 'DifferentialChangeset'); 16 16 + assert_instances_of($changesets, DifferentialChangeset::class); 14 17 $this->changesets = $changesets; 15 18 return $this; 16 19 }

+24 -5

src/applications/differential/query/DifferentialRevisionQuery.php

reviewed

··· 864 864 ); 865 865 } 866 866 867 867 + /** 868 868 + * @param array<DifferentialRevision> $revisions 869 869 + */ 867 870 private function loadCommitPHIDs(array $revisions) { 868 868 - assert_instances_of($revisions, 'DifferentialRevision'); 871 871 + assert_instances_of($revisions, DifferentialRevision::class); 869 872 870 873 if (!$revisions) { 871 874 return; ··· 887 890 } 888 891 } 889 892 893 893 + /** 894 894 + * @param AphrontDatabaseConnection $conn_r 895 895 + * @param array<DifferentialRevision> $revisions 896 896 + */ 890 897 private function loadDiffIDs($conn_r, array $revisions) { 891 891 - assert_instances_of($revisions, 'DifferentialRevision'); 898 898 + assert_instances_of($revisions, DifferentialRevision::class); 892 899 893 900 $diff_table = new DifferentialDiff(); 894 901 ··· 907 914 } 908 915 } 909 916 917 917 + /** 918 918 + * @param AphrontDatabaseConnection $conn_r 919 919 + * @param array<DifferentialRevision> $revisions 920 920 + */ 910 921 private function loadActiveDiffs($conn_r, array $revisions) { 911 911 - assert_instances_of($revisions, 'DifferentialRevision'); 922 922 + assert_instances_of($revisions, DifferentialRevision::class); 912 923 913 924 $diff_table = new DifferentialDiff(); 914 925 ··· 933 944 } 934 945 } 935 946 947 947 + /** 948 948 + * @param AphrontDatabaseConnection $conn_r 949 949 + * @param array<DifferentialRevision> $revisions 950 950 + */ 936 951 private function loadHashes( 937 952 AphrontDatabaseConnection $conn_r, 938 953 array $revisions) { 939 939 - assert_instances_of($revisions, 'DifferentialRevision'); 954 954 + assert_instances_of($revisions, DifferentialRevision::class); 940 955 941 956 $data = queryfx_all( 942 957 $conn_r, ··· 955 970 } 956 971 } 957 972 973 973 + /** 974 974 + * @param AphrontDatabaseConnection $conn 975 975 + * @param array<DifferentialRevision> $revisions 976 976 + */ 958 977 private function loadReviewers( 959 978 AphrontDatabaseConnection $conn, 960 979 array $revisions) { 961 980 962 962 - assert_instances_of($revisions, 'DifferentialRevision'); 981 981 + assert_instances_of($revisions, DifferentialRevision::class); 963 982 964 983 $reviewer_table = new DifferentialReviewer(); 965 984 $reviewer_rows = queryfx_all(

+6 -1

src/applications/differential/query/DifferentialRevisionSearchEngine.php

reviewed

··· 172 172 return parent::buildSavedQueryFromBuiltin($query_key); 173 173 } 174 174 175 175 + /** 176 176 + * @param array<DifferentialRevision> $revisions 177 177 + * @param PhabricatorSavedQuery $query 178 178 + * @param array<PhabricatorObjectHandle> $handles 179 179 + */ 175 180 protected function renderResultList( 176 181 array $revisions, 177 182 PhabricatorSavedQuery $query, 178 183 array $handles) { 179 179 - assert_instances_of($revisions, 'DifferentialRevision'); 184 184 + assert_instances_of($revisions, DifferentialRevision::class); 180 185 181 186 $viewer = $this->requireViewer(); 182 187 $template = id(new DifferentialRevisionListView())

+13 -3

src/applications/differential/render/DifferentialChangesetRenderer.php

reviewed

··· 177 177 return $this->markupEngine; 178 178 } 179 179 180 180 + /** 181 181 + * @param array<PhabricatorObjectHandle> $handles 182 182 + */ 180 183 public function setHandles(array $handles) { 181 181 - assert_instances_of($handles, 'PhabricatorObjectHandle'); 184 184 + assert_instances_of($handles, PhabricatorObjectHandle::class); 182 185 $this->handles = $handles; 183 186 return $this; 184 187 } ··· 261 264 return $this->documentEngineBlocks; 262 265 } 263 266 267 267 + /** 268 268 + * @param array<PhabricatorInlineComment> $new_comments 269 269 + */ 264 270 public function setNewComments(array $new_comments) { 265 271 foreach ($new_comments as $line_number => $comments) { 266 266 - assert_instances_of($comments, 'PhabricatorInlineComment'); 272 272 + assert_instances_of($comments, PhabricatorInlineComment::class); 267 273 } 268 274 $this->newComments = $new_comments; 269 275 return $this; 270 276 } 277 277 + 271 278 protected function getNewComments() { 272 279 return $this->newComments; 273 280 } 274 281 282 282 + /** 283 283 + * @param array<PhabricatorInlineComment> $old_comments 284 284 + */ 275 285 public function setOldComments(array $old_comments) { 276 286 foreach ($old_comments as $line_number => $comments) { 277 277 - assert_instances_of($comments, 'PhabricatorInlineComment'); 287 287 + assert_instances_of($comments, PhabricatorInlineComment::class); 278 288 } 279 289 $this->oldComments = $old_comments; 280 290 return $this;

+4 -1

src/applications/differential/render/DifferentialRawDiffRenderer.php

reviewed

··· 16 16 return $this->format; 17 17 } 18 18 19 19 + /** 20 20 + * @param array<DifferentialChangeset> $changesets 21 21 + */ 19 22 public function setChangesets(array $changesets) { 20 20 - assert_instances_of($changesets, 'DifferentialChangeset'); 23 23 + assert_instances_of($changesets, DifferentialChangeset::class); 21 24 22 25 $this->changesets = $changesets; 23 26 return $this;

+4 -1

src/applications/differential/storage/DifferentialChangeset.php

reviewed

··· 85 85 return $this->getAddLines() + $this->getDelLines(); 86 86 } 87 87 88 88 + /** 89 89 + * @param array<DifferentialHunk> $hunks 90 90 + */ 88 91 public function attachHunks(array $hunks) { 89 89 - assert_instances_of($hunks, 'DifferentialHunk'); 92 92 + assert_instances_of($hunks, DifferentialHunk::class); 90 93 $this->hunks = $hunks; 91 94 return $this; 92 95 }

+13 -3

src/applications/differential/storage/DifferentialDiff.php

reviewed

··· 98 98 return $this; 99 99 } 100 100 101 101 + /** 102 102 + * @param array<DifferentialChangeset> $changesets 103 103 + */ 101 104 public function attachChangesets(array $changesets) { 102 102 - assert_instances_of($changesets, 'DifferentialChangeset'); 105 105 + assert_instances_of($changesets, DifferentialChangeset::class); 103 106 $this->changesets = $changesets; 104 107 return $this; 105 108 } ··· 148 151 return $diff; 149 152 } 150 153 154 154 + /** 155 155 + * @param PhabricatorUser $actor 156 156 + * @param array<ArcanistDiffChange> $changes 157 157 + */ 151 158 public static function newFromRawChanges( 152 159 PhabricatorUser $actor, 153 160 array $changes) { 154 161 155 155 - assert_instances_of($changes, 'ArcanistDiffChange'); 162 162 + assert_instances_of($changes, ArcanistDiffChange::class); 156 163 157 164 $diff = self::initializeNewDiff($actor); 158 165 return self::buildChangesetsFromRawChanges($diff, $changes); 159 166 } 160 167 168 168 + /** 169 169 + * @param array<ArcanistDiffChange> $changes 170 170 + */ 161 171 public static function newEphemeralFromRawChanges(array $changes) { 162 162 - assert_instances_of($changes, 'ArcanistDiffChange'); 172 172 + assert_instances_of($changes, ArcanistDiffChange::class); 163 173 164 174 $diff = id(new DifferentialDiff())->makeEphemeral(); 165 175 return self::buildChangesetsFromRawChanges($diff, $changes);

+4 -1

src/applications/differential/storage/DifferentialRevision.php

reviewed

··· 554 554 return $this->assertAttached($this->reviewerStatus); 555 555 } 556 556 557 557 + /** 558 558 + * @param array<DifferentialReviewer> $reviewers 559 559 + */ 557 560 public function attachReviewers(array $reviewers) { 558 558 - assert_instances_of($reviewers, 'DifferentialReviewer'); 561 561 + assert_instances_of($reviewers, DifferentialReviewer::class); 559 562 $reviewers = mpull($reviewers, null, 'getReviewerPHID'); 560 563 $this->reviewerStatus = $reviewers; 561 564 return $this;

+6 -2

src/applications/differential/storage/DifferentialTransactionComment.php

reviewed

··· 72 72 return ($this->getTransactionPHID() != null); 73 73 } 74 74 75 75 + /** 76 76 + * @param array<DifferentialTransaction> $inlines 77 77 + * @param array<DifferentialChangeset> $changesets 78 78 + */ 75 79 public static function sortAndGroupInlines( 76 80 array $inlines, 77 81 array $changesets) { 78 78 - assert_instances_of($inlines, 'DifferentialTransaction'); 79 79 - assert_instances_of($changesets, 'DifferentialChangeset'); 82 82 + assert_instances_of($inlines, DifferentialTransaction::class); 83 83 + assert_instances_of($changesets, DifferentialChangeset::class); 80 84 81 85 $changesets = mpull($changesets, null, 'getID'); 82 86 $changesets = msort($changesets, 'getFilename');

+4 -1

src/applications/differential/view/DifferentialLocalCommitsView.php

reviewed

··· 10 10 return $this; 11 11 } 12 12 13 13 + /** 14 14 + * @param array<PhabricatorRepositoryCommit> $commits 15 15 + */ 13 16 public function setCommitsForLinks(array $commits) { 14 14 - assert_instances_of($commits, 'PhabricatorRepositoryCommit'); 17 17 + assert_instances_of($commits, PhabricatorRepositoryCommit::class); 15 18 $this->commitsForLinks = $commits; 16 19 return $this; 17 20 }

+8 -2

src/applications/differential/view/DifferentialReviewersView.php

reviewed

··· 6 6 private $handles; 7 7 private $diff; 8 8 9 9 + /** 10 10 + * @param array<DifferentialReviewer> $reviewers 11 11 + */ 9 12 public function setReviewers(array $reviewers) { 10 10 - assert_instances_of($reviewers, 'DifferentialReviewer'); 13 13 + assert_instances_of($reviewers, DifferentialReviewer::class); 11 14 $this->reviewers = $reviewers; 12 15 return $this; 13 16 } 14 17 18 18 + /** 19 19 + * @param array<PhabricatorObjectHandle> $handles 20 20 + */ 15 21 public function setHandles(array $handles) { 16 16 - assert_instances_of($handles, 'PhabricatorObjectHandle'); 22 22 + assert_instances_of($handles, PhabricatorObjectHandle::class); 17 23 $this->handles = $handles; 18 24 return $this; 19 25 }

+4 -1

src/applications/differential/view/DifferentialRevisionListView.php

reviewed

··· 32 32 return $this; 33 33 } 34 34 35 35 + /** 36 36 + * @param array<DifferentialRevision> $revisions 37 37 + */ 35 38 public function setRevisions(array $revisions) { 36 36 - assert_instances_of($revisions, 'DifferentialRevision'); 39 39 + assert_instances_of($revisions, DifferentialRevision::class); 37 40 $this->revisions = $revisions; 38 41 return $this; 39 42 }

+8 -2

src/applications/differential/view/DifferentialRevisionUpdateHistoryView.php

reviewed

··· 8 8 private $commitsForLinks = array(); 9 9 private $unitStatus = array(); 10 10 11 11 + /** 12 12 + * @param array<DifferentialDiff> $diffs 13 13 + */ 11 14 public function setDiffs(array $diffs) { 12 12 - assert_instances_of($diffs, 'DifferentialDiff'); 15 15 + assert_instances_of($diffs, DifferentialDiff::class); 13 16 $this->diffs = $diffs; 14 17 return $this; 15 18 } ··· 24 27 return $this; 25 28 } 26 29 30 30 + /** 31 31 + * @param array<PhabricatorRepositoryCommit> $commits 32 32 + */ 27 33 public function setCommitsForLinks(array $commits) { 28 28 - assert_instances_of($commits, 'PhabricatorRepositoryCommit'); 34 34 + assert_instances_of($commits, PhabricatorRepositoryCommit::class); 29 35 $this->commitsForLinks = $commits; 30 36 return $this; 31 37 }

+4 -1

src/applications/differential/view/DifferentialTransactionView.php

reviewed

··· 35 35 return $this->revision; 36 36 } 37 37 38 38 + /** 39 39 + * @param array<DifferentialChangeset> $changesets 40 40 + */ 38 41 public function setChangesets(array $changesets) { 39 39 - assert_instances_of($changesets, 'DifferentialChangeset'); 42 42 + assert_instances_of($changesets, DifferentialChangeset::class); 40 43 $this->changesets = $changesets; 41 44 return $this; 42 45 }

+6 -3

src/applications/herald/adapter/HeraldAdapter.php

reviewed

··· 143 143 ->getHeraldFieldValue($this->getObject()); 144 144 } 145 145 146 146 + /** 147 147 + * @param array<HeraldEffect> $effects 148 148 + */ 146 149 public function applyHeraldEffects(array $effects) { 147 147 - assert_instances_of($effects, 'HeraldEffect'); 150 150 + assert_instances_of($effects, HeraldEffect::class); 148 151 149 152 $result = array(); 150 153 foreach ($effects as $effect) { ··· 171 174 * These transactions are set by @{class:PhabricatorApplicationEditor} 172 175 * automatically, before it invokes Herald. 173 176 * 174 174 - * @param list<PhabricatorApplicationTransaction> $xactions List of 177 177 + * @param array<PhabricatorApplicationTransaction> $xactions List of 175 178 * transactions. 176 179 * @return $this 177 180 */ 178 181 final public function setAppliedTransactions(array $xactions) { 179 179 - assert_instances_of($xactions, 'PhabricatorApplicationTransaction'); 182 182 + assert_instances_of($xactions, PhabricatorApplicationTransaction::class); 180 183 $this->appliedTransactions = $xactions; 181 184 return $this; 182 185 }

+5 -1

src/applications/herald/controller/HeraldRuleController.php

reviewed

··· 710 710 HeraldActionGroup::getAllActionGroups()); 711 711 } 712 712 713 713 + /** 714 714 + * @param array $item_map 715 715 + * @param array<HeraldGroup> $group_list 716 716 + */ 713 717 private function getGroups(array $item_map, array $group_list) { 714 714 - assert_instances_of($group_list, 'HeraldGroup'); 718 718 + assert_instances_of($group_list, HeraldGroup::class); 715 719 716 720 $groups = array(); 717 721 foreach ($item_map as $group_key => $options) {

+9 -2

src/applications/herald/editor/HeraldRuleSerializer.php

reviewed

··· 12 12 $rule->getRepetitionPolicyStringConstant()); 13 13 } 14 14 15 15 + /** 16 16 + * @param $match_all 17 17 + * @param array<HeraldCondition> $conditions 18 18 + * @param array<HeraldActionRecord> $actions 19 19 + * @param $repetition_policy 20 20 + * @return array 21 21 + */ 15 22 public function serializeRuleComponents( 16 23 $match_all, 17 24 array $conditions, 18 25 array $actions, 19 26 $repetition_policy) { 20 27 21 21 - assert_instances_of($conditions, 'HeraldCondition'); 22 22 - assert_instances_of($actions, 'HeraldActionRecord'); 28 28 + assert_instances_of($conditions, HeraldCondition::class); 29 29 + assert_instances_of($actions, HeraldActionRecord::class); 23 30 24 31 $conditions_array = array(); 25 32 foreach ($conditions as $condition) {

+15 -4

src/applications/herald/engine/HeraldEngine.php

reviewed

··· 122 122 return $this->ruleResults[$phid]; 123 123 } 124 124 125 125 + /** 126 126 + * @param array<HeraldRule> $rules 127 127 + * @param HeraldAdapter $object 128 128 + * @return array 129 129 + */ 125 130 public function applyRules(array $rules, HeraldAdapter $object) { 126 126 - assert_instances_of($rules, 'HeraldRule'); 131 131 + assert_instances_of($rules, HeraldRule::class); 127 132 $t_start = microtime(true); 128 133 129 134 // Rules execute in a well-defined order: sort them into execution order. ··· 254 259 return $effects; 255 260 } 256 261 262 262 + /** 263 263 + * @param array<HeraldEffect> $effects 264 264 + * @param HeraldAdapter $adapter 265 265 + * @param array<HeraldRule> $rules 266 266 + * @return array 267 267 + */ 257 268 public function applyEffects( 258 269 array $effects, 259 270 HeraldAdapter $adapter, 260 271 array $rules) { 261 261 - assert_instances_of($effects, 'HeraldEffect'); 262 262 - assert_instances_of($rules, 'HeraldRule'); 272 272 + assert_instances_of($effects, HeraldEffect::class); 273 273 + assert_instances_of($rules, HeraldRule::class); 263 274 264 275 $this->transcript->setDryRun((int)$this->getDryRun()); 265 276 ··· 275 286 $xscripts = $adapter->applyHeraldEffects($effects); 276 287 } 277 288 278 278 - assert_instances_of($xscripts, 'HeraldApplyTranscript'); 289 289 + assert_instances_of($xscripts, HeraldApplyTranscript::class); 279 290 foreach ($xscripts as $apply_xscript) { 280 291 $this->transcript->addApplyTranscript($apply_xscript); 281 292 }

+6 -1

src/applications/herald/query/HeraldRuleSearchEngine.php

reviewed

··· 130 130 return parent::buildSavedQueryFromBuiltin($query_key); 131 131 } 132 132 133 133 + /** 134 134 + * @param array<HeraldRule> $rules 135 135 + * @param PhabricatorSavedQuery $query 136 136 + * @param array $handles 137 137 + */ 133 138 protected function renderResultList( 134 139 array $rules, 135 140 PhabricatorSavedQuery $query, 136 141 array $handles) { 137 137 - assert_instances_of($rules, 'HeraldRule'); 142 142 + assert_instances_of($rules, HeraldRule::class); 138 143 $viewer = $this->requireViewer(); 139 144 140 145 $list = id(new HeraldRuleListView())

+6 -1

src/applications/herald/query/HeraldTranscriptSearchEngine.php

reviewed

··· 104 104 return mpull($transcripts, 'getObjectPHID'); 105 105 } 106 106 107 107 + /** 108 108 + * @param array<HeraldTranscript> $transcripts 109 109 + * @param PhabricatorSavedQuery $query 110 110 + * @param array $handles 111 111 + */ 107 112 protected function renderResultList( 108 113 array $transcripts, 109 114 PhabricatorSavedQuery $query, 110 115 array $handles) { 111 111 - assert_instances_of($transcripts, 'HeraldTranscript'); 116 116 + assert_instances_of($transcripts, HeraldTranscript::class); 112 117 113 118 $viewer = $this->requireViewer(); 114 119

+6 -1

src/applications/herald/query/HeraldWebhookSearchEngine.php

reviewed

··· 68 68 return parent::buildSavedQueryFromBuiltin($query_key); 69 69 } 70 70 71 71 + /** 72 72 + * @param array<HeraldWebhook> $hooks 73 73 + * @param PhabricatorSavedQuery $query 74 74 + * @param array<PhabricatorObjectHandle> $handles 75 75 + */ 71 76 protected function renderResultList( 72 77 array $hooks, 73 78 PhabricatorSavedQuery $query, 74 79 array $handles) { 75 75 - assert_instances_of($hooks, 'HeraldWebhook'); 80 80 + assert_instances_of($hooks, HeraldWebhook::class); 76 81 77 82 $viewer = $this->requireViewer(); 78 83

+21 -5

src/applications/herald/storage/HeraldRule.php

reviewed

··· 90 90 $this->getID()); 91 91 } 92 92 93 93 + /** 94 94 + * @param array<HeraldCondition> $conditions 95 95 + */ 93 96 public function attachConditions(array $conditions) { 94 94 - assert_instances_of($conditions, 'HeraldCondition'); 97 97 + assert_instances_of($conditions, HeraldCondition::class); 95 98 $this->conditions = $conditions; 96 99 return $this; 97 100 } ··· 110 113 $this->getID()); 111 114 } 112 115 116 116 + /** 117 117 + * @param array<HeraldActionRecord> $actions 118 118 + */ 113 119 public function attachActions(array $actions) { 114 120 // TODO: validate actions have been attached. 115 115 - assert_instances_of($actions, 'HeraldActionRecord'); 121 121 + assert_instances_of($actions, HeraldActionRecord::class); 116 122 $this->actions = $actions; 117 123 return $this; 118 124 } ··· 121 127 return $this->actions; 122 128 } 123 129 130 130 + /** 131 131 + * @param array<HeraldCondition> $conditions 132 132 + */ 124 133 public function saveConditions(array $conditions) { 125 125 - assert_instances_of($conditions, 'HeraldCondition'); 134 134 + assert_instances_of($conditions, HeraldCondition::class); 126 135 return $this->saveChildren( 127 136 id(new HeraldCondition())->getTableName(), 128 137 $conditions); 129 138 } 130 139 140 140 + /** 141 141 + * @param array<HeraldActionRecord> $actions 142 142 + */ 131 143 public function saveActions(array $actions) { 132 132 - assert_instances_of($actions, 'HeraldActionRecord'); 144 144 + assert_instances_of($actions, HeraldActionRecord::class); 133 145 return $this->saveChildren( 134 146 id(new HeraldActionRecord())->getTableName(), 135 147 $actions); 136 148 } 137 149 150 150 + /** 151 151 + * @param string $table_name 152 152 + * @param array<HeraldDAO> $children 153 153 + */ 138 154 protected function saveChildren($table_name, array $children) { 139 139 - assert_instances_of($children, 'HeraldDAO'); 155 155 + assert_instances_of($children, parent::class); 140 156 141 157 if (!$this->getID()) { 142 158 throw new PhutilInvalidStateException('save');

+4 -1

src/applications/herald/view/HeraldRuleListView.php

reviewed

··· 5 5 6 6 private $rules; 7 7 8 8 + /** 9 9 + * @param array<HeraldRule> $rules 10 10 + */ 8 11 public function setRules(array $rules) { 9 9 - assert_instances_of($rules, 'HeraldRule'); 12 12 + assert_instances_of($rules, HeraldRule::class); 10 13 $this->rules = $rules; 11 14 return $this; 12 15 }

+4 -1

src/applications/herald/view/HeraldWebhookRequestListView.php

reviewed

··· 6 6 private $requests; 7 7 private $highlightID; 8 8 9 9 + /** 10 10 + * @param array<HeraldWebhookRequest> $requests 11 11 + */ 9 12 public function setRequests(array $requests) { 10 10 - assert_instances_of($requests, 'HeraldWebhookRequest'); 13 13 + assert_instances_of($requests, HeraldWebhookRequest::class); 11 14 $this->requests = $requests; 12 15 return $this; 13 16 }

+6 -1

src/applications/paste/query/PhabricatorPasteSearchEngine.php

reviewed

··· 131 131 return mpull($pastes, 'getAuthorPHID'); 132 132 } 133 133 134 134 + /** 135 135 + * @param array<PhabricatorPaste> $pastes 136 136 + * @param PhabricatorSavedQuery $query 137 137 + * @param array<PhabricatorObjectHandle> $handles 138 138 + */ 134 139 protected function renderResultList( 135 140 array $pastes, 136 141 PhabricatorSavedQuery $query, 137 142 array $handles) { 138 138 - assert_instances_of($pastes, 'PhabricatorPaste'); 143 143 + assert_instances_of($pastes, PhabricatorPaste::class); 139 144 140 145 $viewer = $this->requireViewer(); 141 146

+12 -3

src/applications/pholio/query/PholioImageQuery.php

reviewed

··· 23 23 return $this; 24 24 } 25 25 26 26 + /** 27 27 + * @param array<PholioMock> $mocks 28 28 + */ 26 29 public function withMocks(array $mocks) { 27 27 - assert_instances_of($mocks, 'PholioMock'); 30 30 + assert_instances_of($mocks, PholioMock::class); 28 31 29 32 $mocks = mpull($mocks, null, 'getPHID'); 30 33 $this->mocks = $mocks; ··· 74 77 return $where; 75 78 } 76 79 80 80 + /** 81 81 + * @param array<PholioImage> $images 82 82 + */ 77 83 protected function willFilterPage(array $images) { 78 78 - assert_instances_of($images, 'PholioImage'); 84 84 + assert_instances_of($images, PholioImage::class); 79 85 80 86 $mock_phids = array(); 81 87 foreach ($images as $image) { ··· 117 123 return $images; 118 124 } 119 125 126 126 + /** 127 127 + * @param array<PholioImage> $images 128 128 + */ 120 129 protected function didFilterPage(array $images) { 121 121 - assert_instances_of($images, 'PholioImage'); 130 130 + assert_instances_of($images, PholioImage::class); 122 131 123 132 $file_phids = mpull($images, 'getFilePHID'); 124 133

+6 -1

src/applications/pholio/query/PholioMockSearchEngine.php

reviewed

··· 83 83 return parent::buildSavedQueryFromBuiltin($query_key); 84 84 } 85 85 86 86 + /** 87 87 + * @param array<PholioMock> $mocks 88 88 + * @param PhabricatorSavedQuery $query 89 89 + * @param array $handles 90 90 + */ 86 91 protected function renderResultList( 87 92 array $mocks, 88 93 PhabricatorSavedQuery $query, 89 94 array $handles) { 90 90 - assert_instances_of($mocks, 'PholioMock'); 95 95 + assert_instances_of($mocks, PholioMock::class); 91 96 92 97 $viewer = $this->requireViewer(); 93 98 $handles = $viewer->loadHandles(mpull($mocks, 'getAuthorPHID'));

+4 -1

src/applications/pholio/storage/PholioImage.php

reviewed

··· 70 70 return (bool)$this->getMockPHID(); 71 71 } 72 72 73 73 + /** 74 74 + * @param array<PholioTransactionComment> $inline_comments 75 75 + */ 73 76 public function attachInlineComments(array $inline_comments) { 74 74 - assert_instances_of($inline_comments, 'PholioTransactionComment'); 77 77 + assert_instances_of($inline_comments, PholioTransactionComment::class); 75 78 $this->inlineComments = $inline_comments; 76 79 return $this; 77 80 }

+4 -1

src/applications/pholio/storage/PholioMock.php

reviewed

··· 78 78 return PholioMockPHIDType::TYPECONST; 79 79 } 80 80 81 81 + /** 82 82 + * @param array<PholioImage> $images 83 83 + */ 81 84 public function attachImages(array $images) { 82 82 - assert_instances_of($images, 'PholioImage'); 85 85 + assert_instances_of($images, PholioImage::class); 83 86 $images = mpull($images, null, 'getPHID'); 84 87 $images = msort($images, 'getSequence'); 85 88 $this->images = $images;

+4 -1

src/applications/phriction/controller/PhrictionDiffController.php

reviewed

··· 215 215 $label); 216 216 } 217 217 218 218 + /** 219 219 + * @param array<PhrictionContent> $content 220 220 + */ 218 221 private function renderComparisonTable(array $content) { 219 219 - assert_instances_of($content, 'PhrictionContent'); 222 222 + assert_instances_of($content, PhrictionContent::class); 220 223 221 224 $viewer = $this->getViewer(); 222 225

+6 -1

src/applications/phriction/query/PhrictionContentSearchEngine.php

reviewed

··· 72 72 return parent::buildSavedQueryFromBuiltin($query_key); 73 73 } 74 74 75 75 + /** 76 76 + * @param array<PhrictionContent> $contents 77 77 + * @param PhabricatorSavedQuery $query 78 78 + * @param array<PhabricatorObjectHandle> $handles 79 79 + */ 75 80 protected function renderResultList( 76 81 array $contents, 77 82 PhabricatorSavedQuery $query, 78 83 array $handles) { 79 79 - assert_instances_of($contents, 'PhrictionContent'); 84 84 + assert_instances_of($contents, PhrictionContent::class); 80 85 throw new PhutilMethodNotImplementedException(); 81 86 } 82 87

+6 -2

src/applications/phriction/query/PhrictionDocumentSearchEngine.php

reviewed

··· 104 104 return $phids; 105 105 } 106 106 107 107 - 107 107 + /** 108 108 + * @param array<PhrictionDocument> $documents 109 109 + * @param PhabricatorSavedQuery $query 110 110 + * @param array<PhabricatorObjectHandle> $handles 111 111 + */ 108 112 protected function renderResultList( 109 113 array $documents, 110 114 PhabricatorSavedQuery $query, 111 115 array $handles) { 112 112 - assert_instances_of($documents, 'PhrictionDocument'); 116 116 + assert_instances_of($documents, PhrictionDocument::class); 113 117 114 118 $viewer = $this->requireViewer(); 115 119

+5 -1

src/applications/repository/engine/PhabricatorRepositoryEngine.php

reviewed

··· 124 124 PhabricatorWorker::scheduleTask($class, $data, $options); 125 125 } 126 126 127 127 + /** 128 128 + * @param PhabricatorRepository $repository 129 129 + * @param array<PhabricatorRepositoryCommitRef> $refs 130 130 + */ 127 131 final protected function getImportTaskPriority( 128 132 PhabricatorRepository $repository, 129 133 array $refs) { 130 130 - assert_instances_of($refs, 'PhabricatorRepositoryCommitRef'); 134 134 + assert_instances_of($refs, PhabricatorRepositoryCommitRef::class); 131 135 132 136 // If the repository is importing for the first time, we schedule tasks 133 137 // at IMPORT priority, which is very low. Making progress on importing a

+10 -2

src/applications/repository/engine/PhabricatorRepositoryRefEngine.php

reviewed

··· 121 121 } 122 122 } 123 123 124 124 + /** 125 125 + * @param PhabricatorRepository $repository 126 126 + * @param array<PhabricatorRepositoryRefCursor> $cursors 127 127 + */ 124 128 private function getCursorsForUpdate( 125 129 PhabricatorRepository $repository, 126 130 array $cursors) { 127 127 - assert_instances_of($cursors, 'PhabricatorRepositoryRefCursor'); 131 131 + assert_instances_of($cursors, PhabricatorRepositoryRefCursor::class); 128 132 129 133 $publisher = $repository->newPublisher(); 130 134 ··· 145 149 return $results; 146 150 } 147 151 152 152 + /** 153 153 + * @param PhabricatorRepository $repository 154 154 + * @param array<DiffusionRepositoryRef> $branches 155 155 + */ 148 156 private function updateBranchStates( 149 157 PhabricatorRepository $repository, 150 158 array $branches) { 151 159 152 152 - assert_instances_of($branches, 'DiffusionRepositoryRef'); 160 160 + assert_instances_of($branches, DiffusionRepositoryRef::class); 153 161 $viewer = $this->getViewer(); 154 162 155 163 $all_cursors = id(new PhabricatorRepositoryRefCursorQuery())

+4 -1

src/applications/repository/query/PhabricatorRepositoryQuery.php

reviewed

··· 234 234 return $repositories; 235 235 } 236 236 237 237 + /** 238 238 + * @param array<PhabricatorRepository> $repositories 239 239 + */ 237 240 protected function willFilterPage(array $repositories) { 238 238 - assert_instances_of($repositories, 'PhabricatorRepository'); 241 241 + assert_instances_of($repositories, PhabricatorRepository::class); 239 242 240 243 // TODO: Denormalize repository status into the PhabricatorRepository 241 244 // table so we can do this filtering in the database.

+6 -1

src/applications/repository/query/PhabricatorRepositorySearchEngine.php

reviewed

··· 162 162 return array_mergev(mpull($repositories, 'getProjectPHIDs')); 163 163 } 164 164 165 165 + /** 166 166 + * @param array<PhabricatorRepository> $repositories 167 167 + * @param PhabricatorSavedQuery $query 168 168 + * @param array<PhabricatorObjectHandle> $handles 169 169 + */ 165 170 protected function renderResultList( 166 171 array $repositories, 167 172 PhabricatorSavedQuery $query, 168 173 array $handles) { 169 169 - assert_instances_of($repositories, 'PhabricatorRepository'); 174 174 + assert_instances_of($repositories, PhabricatorRepository::class); 170 175 171 176 $viewer = $this->requireViewer(); 172 177

+8 -2

src/applications/repository/storage/PhabricatorRepository.php

reviewed

··· 1954 1954 return array_values($refs); 1955 1955 } 1956 1956 1957 1957 + /** 1958 1958 + * @param array<DiffusionServiceRef> $refs 1959 1959 + */ 1957 1960 private function sortReadableAlmanacServiceRefs(array $refs) { 1958 1958 - assert_instances_of($refs, 'DiffusionServiceRef'); 1961 1961 + assert_instances_of($refs, DiffusionServiceRef::class); 1959 1962 shuffle($refs); 1960 1963 return $refs; 1961 1964 } 1962 1965 1966 1966 + /** 1967 1967 + * @param array<DiffusionServiceRef> $refs 1968 1968 + */ 1963 1969 private function sortWritableAlmanacServiceRefs(array $refs) { 1964 1964 - assert_instances_of($refs, 'DiffusionServiceRef'); 1970 1970 + assert_instances_of($refs, DiffusionServiceRef::class); 1965 1971 1966 1972 // See T13109 for discussion of how this method routes requests. 1967 1973

+7 -2

src/applications/repository/storage/PhabricatorRepositoryCommit.php

reviewed

··· 183 183 return $this->assertAttached($this->commitData); 184 184 } 185 185 186 186 + /** 187 187 + * @param array<PhabricatorRepositoryAuditRequest> $audits 188 188 + */ 186 189 public function attachAudits(array $audits) { 187 187 - assert_instances_of($audits, 'PhabricatorRepositoryAuditRequest'); 190 190 + assert_instances_of($audits, PhabricatorRepositoryAuditRequest::class); 188 191 $this->audits = $audits; 189 192 return $this; 190 193 } ··· 302 305 /** 303 306 * Synchronize a commit's overall audit status with the individual audit 304 307 * triggers. 308 308 + * 309 309 + * @param array<PhabricatorRepositoryAuditRequest> $requests 305 310 */ 306 311 public function updateAuditStatus(array $requests) { 307 307 - assert_instances_of($requests, 'PhabricatorRepositoryAuditRequest'); 312 312 + assert_instances_of($requests, PhabricatorRepositoryAuditRequest::class); 308 313 309 314 $any_concern = false; 310 315 $any_accept = false;

+4 -1

src/applications/repository/storage/PhabricatorRepositoryPushEvent.php

reviewed

··· 81 81 return $this->assertAttached($this->logs); 82 82 } 83 83 84 84 + /** 85 85 + * @param array<PhabricatorRepositoryPushLog> $logs 86 86 + */ 84 87 public function saveWithLogs(array $logs) { 85 85 - assert_instances_of($logs, 'PhabricatorRepositoryPushLog'); 88 88 + assert_instances_of($logs, PhabricatorRepositoryPushLog::class); 86 89 87 90 $this->openTransaction(); 88 91 $this->save();

+4 -1

src/applications/repository/storage/PhabricatorRepositoryRefCursor.php

reviewed

··· 74 74 return $this->assertAttached($this->repository); 75 75 } 76 76 77 77 + /** 78 78 + * @param array<PhabricatorRepositoryRefPosition> $positions 79 79 + */ 77 80 public function attachPositions(array $positions) { 78 78 - assert_instances_of($positions, 'PhabricatorRepositoryRefPosition'); 81 81 + assert_instances_of($positions, PhabricatorRepositoryRefPosition::class); 79 82 $this->positions = $positions; 80 83 return $this; 81 84 }

+4 -1

src/applications/subscriptions/view/SubscriptionListDialogBuilder.php

reviewed

··· 16 16 return $this->viewer; 17 17 } 18 18 19 19 + /** 20 20 + * @param array<PhabricatorObjectHandle> $handles 21 21 + */ 19 22 public function setHandles(array $handles) { 20 20 - assert_instances_of($handles, 'PhabricatorObjectHandle'); 23 23 + assert_instances_of($handles, PhabricatorObjectHandle::class); 21 24 $this->handles = $handles; 22 25 return $this; 23 26 }