| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file | |
| 2 // for details. All rights reserved. Use of this source code is governed by a | |
| 3 // BSD-style license that can be found in the LICENSE file. | |
| 4 // | |
| 5 // This file has been automatically generated. Please do not edit it manually. | |
| 6 // To regenerate the file, use the script | |
| 7 // "pkg/analysis_server/tool/spec/generate_files". | |
| 8 | |
| 9 /** | |
| 10 * Matchers for data types defined in the analysis server API | |
| 11 */ | |
| 12 library test.integration.protocol.matchers; | |
| 13 | |
| 14 import 'package:test/test.dart'; | |
| 15 | |
| 16 import 'integration_tests.dart'; | |
| 17 | |
| 18 /** | |
| 19 * server.getVersion params | |
| 20 */ | |
| 21 final Matcher isServerGetVersionParams = isNull; | |
| 22 | |
| 23 /** | |
| 24 * server.getVersion result | |
| 25 * | |
| 26 * { | |
| 27 * "version": String | |
| 28 * } | |
| 29 */ | |
| 30 final Matcher isServerGetVersionResult = new LazyMatcher(() => | |
| 31 new MatchesJsonObject("server.getVersion result", {"version": isString})); | |
| 32 | |
| 33 /** | |
| 34 * server.shutdown params | |
| 35 */ | |
| 36 final Matcher isServerShutdownParams = isNull; | |
| 37 | |
| 38 /** | |
| 39 * server.shutdown result | |
| 40 */ | |
| 41 final Matcher isServerShutdownResult = isNull; | |
| 42 | |
| 43 /** | |
| 44 * server.setSubscriptions params | |
| 45 * | |
| 46 * { | |
| 47 * "subscriptions": List<ServerService> | |
| 48 * } | |
| 49 */ | |
| 50 final Matcher isServerSetSubscriptionsParams = new LazyMatcher(() => | |
| 51 new MatchesJsonObject("server.setSubscriptions params", | |
| 52 {"subscriptions": isListOf(isServerService)})); | |
| 53 | |
| 54 /** | |
| 55 * server.setSubscriptions result | |
| 56 */ | |
| 57 final Matcher isServerSetSubscriptionsResult = isNull; | |
| 58 | |
| 59 /** | |
| 60 * server.connected params | |
| 61 * | |
| 62 * { | |
| 63 * "version": String | |
| 64 * "pid": int | |
| 65 * "sessionId": optional String | |
| 66 * } | |
| 67 */ | |
| 68 final Matcher isServerConnectedParams = new LazyMatcher(() => | |
| 69 new MatchesJsonObject( | |
| 70 "server.connected params", {"version": isString, "pid": isInt}, | |
| 71 optionalFields: {"sessionId": isString})); | |
| 72 | |
| 73 /** | |
| 74 * server.error params | |
| 75 * | |
| 76 * { | |
| 77 * "isFatal": bool | |
| 78 * "message": String | |
| 79 * "stackTrace": String | |
| 80 * } | |
| 81 */ | |
| 82 final Matcher isServerErrorParams = new LazyMatcher(() => new MatchesJsonObject( | |
| 83 "server.error params", | |
| 84 {"isFatal": isBool, "message": isString, "stackTrace": isString})); | |
| 85 | |
| 86 /** | |
| 87 * server.status params | |
| 88 * | |
| 89 * { | |
| 90 * "analysis": optional AnalysisStatus | |
| 91 * "pub": optional PubStatus | |
| 92 * } | |
| 93 */ | |
| 94 final Matcher isServerStatusParams = new LazyMatcher(() => | |
| 95 new MatchesJsonObject("server.status params", null, | |
| 96 optionalFields: {"analysis": isAnalysisStatus, "pub": isPubStatus})); | |
| 97 | |
| 98 /** | |
| 99 * analysis.getErrors params | |
| 100 * | |
| 101 * { | |
| 102 * "file": FilePath | |
| 103 * } | |
| 104 */ | |
| 105 final Matcher isAnalysisGetErrorsParams = new LazyMatcher(() => | |
| 106 new MatchesJsonObject("analysis.getErrors params", {"file": isFilePath})); | |
| 107 | |
| 108 /** | |
| 109 * analysis.getErrors result | |
| 110 * | |
| 111 * { | |
| 112 * "errors": List<AnalysisError> | |
| 113 * } | |
| 114 */ | |
| 115 final Matcher isAnalysisGetErrorsResult = new LazyMatcher(() => | |
| 116 new MatchesJsonObject( | |
| 117 "analysis.getErrors result", {"errors": isListOf(isAnalysisError)})); | |
| 118 | |
| 119 /** | |
| 120 * analysis.getHover params | |
| 121 * | |
| 122 * { | |
| 123 * "file": FilePath | |
| 124 * "offset": int | |
| 125 * } | |
| 126 */ | |
| 127 final Matcher isAnalysisGetHoverParams = new LazyMatcher(() => | |
| 128 new MatchesJsonObject( | |
| 129 "analysis.getHover params", {"file": isFilePath, "offset": isInt})); | |
| 130 | |
| 131 /** | |
| 132 * analysis.getHover result | |
| 133 * | |
| 134 * { | |
| 135 * "hovers": List<HoverInformation> | |
| 136 * } | |
| 137 */ | |
| 138 final Matcher isAnalysisGetHoverResult = new LazyMatcher(() => | |
| 139 new MatchesJsonObject( | |
| 140 "analysis.getHover result", {"hovers": isListOf(isHoverInformation)})); | |
| 141 | |
| 142 /** | |
| 143 * analysis.getReachableSources params | |
| 144 * | |
| 145 * { | |
| 146 * "file": FilePath | |
| 147 * } | |
| 148 */ | |
| 149 final Matcher isAnalysisGetReachableSourcesParams = new LazyMatcher(() => | |
| 150 new MatchesJsonObject( | |
| 151 "analysis.getReachableSources params", {"file": isFilePath})); | |
| 152 | |
| 153 /** | |
| 154 * analysis.getReachableSources result | |
| 155 * | |
| 156 * { | |
| 157 * "sources": Map<String, List<String>> | |
| 158 * } | |
| 159 */ | |
| 160 final Matcher isAnalysisGetReachableSourcesResult = new LazyMatcher(() => | |
| 161 new MatchesJsonObject("analysis.getReachableSources result", | |
| 162 {"sources": isMapOf(isString, isListOf(isString))})); | |
| 163 | |
| 164 /** | |
| 165 * analysis.getLibraryDependencies params | |
| 166 */ | |
| 167 final Matcher isAnalysisGetLibraryDependenciesParams = isNull; | |
| 168 | |
| 169 /** | |
| 170 * analysis.getLibraryDependencies result | |
| 171 * | |
| 172 * { | |
| 173 * "libraries": List<FilePath> | |
| 174 * "packageMap": Map<String, Map<String, List<FilePath>>> | |
| 175 * } | |
| 176 */ | |
| 177 final Matcher isAnalysisGetLibraryDependenciesResult = new LazyMatcher( | |
| 178 () => new MatchesJsonObject("analysis.getLibraryDependencies result", { | |
| 179 "libraries": isListOf(isFilePath), | |
| 180 "packageMap": | |
| 181 isMapOf(isString, isMapOf(isString, isListOf(isFilePath))) | |
| 182 })); | |
| 183 | |
| 184 /** | |
| 185 * analysis.getNavigation params | |
| 186 * | |
| 187 * { | |
| 188 * "file": FilePath | |
| 189 * "offset": int | |
| 190 * "length": int | |
| 191 * } | |
| 192 */ | |
| 193 final Matcher isAnalysisGetNavigationParams = new LazyMatcher(() => | |
| 194 new MatchesJsonObject("analysis.getNavigation params", | |
| 195 {"file": isFilePath, "offset": isInt, "length": isInt})); | |
| 196 | |
| 197 /** | |
| 198 * analysis.getNavigation result | |
| 199 * | |
| 200 * { | |
| 201 * "files": List<FilePath> | |
| 202 * "targets": List<NavigationTarget> | |
| 203 * "regions": List<NavigationRegion> | |
| 204 * } | |
| 205 */ | |
| 206 final Matcher isAnalysisGetNavigationResult = new LazyMatcher( | |
| 207 () => new MatchesJsonObject("analysis.getNavigation result", { | |
| 208 "files": isListOf(isFilePath), | |
| 209 "targets": isListOf(isNavigationTarget), | |
| 210 "regions": isListOf(isNavigationRegion) | |
| 211 })); | |
| 212 | |
| 213 /** | |
| 214 * analysis.reanalyze params | |
| 215 * | |
| 216 * { | |
| 217 * "roots": optional List<FilePath> | |
| 218 * } | |
| 219 */ | |
| 220 final Matcher isAnalysisReanalyzeParams = new LazyMatcher(() => | |
| 221 new MatchesJsonObject("analysis.reanalyze params", null, | |
| 222 optionalFields: {"roots": isListOf(isFilePath)})); | |
| 223 | |
| 224 /** | |
| 225 * analysis.reanalyze result | |
| 226 */ | |
| 227 final Matcher isAnalysisReanalyzeResult = isNull; | |
| 228 | |
| 229 /** | |
| 230 * analysis.setAnalysisRoots params | |
| 231 * | |
| 232 * { | |
| 233 * "included": List<FilePath> | |
| 234 * "excluded": List<FilePath> | |
| 235 * "packageRoots": optional Map<FilePath, FilePath> | |
| 236 * } | |
| 237 */ | |
| 238 final Matcher isAnalysisSetAnalysisRootsParams = new LazyMatcher(() => | |
| 239 new MatchesJsonObject("analysis.setAnalysisRoots params", | |
| 240 {"included": isListOf(isFilePath), "excluded": isListOf(isFilePath)}, | |
| 241 optionalFields: {"packageRoots": isMapOf(isFilePath, isFilePath)})); | |
| 242 | |
| 243 /** | |
| 244 * analysis.setAnalysisRoots result | |
| 245 */ | |
| 246 final Matcher isAnalysisSetAnalysisRootsResult = isNull; | |
| 247 | |
| 248 /** | |
| 249 * analysis.setGeneralSubscriptions params | |
| 250 * | |
| 251 * { | |
| 252 * "subscriptions": List<GeneralAnalysisService> | |
| 253 * } | |
| 254 */ | |
| 255 final Matcher isAnalysisSetGeneralSubscriptionsParams = new LazyMatcher(() => | |
| 256 new MatchesJsonObject("analysis.setGeneralSubscriptions params", | |
| 257 {"subscriptions": isListOf(isGeneralAnalysisService)})); | |
| 258 | |
| 259 /** | |
| 260 * analysis.setGeneralSubscriptions result | |
| 261 */ | |
| 262 final Matcher isAnalysisSetGeneralSubscriptionsResult = isNull; | |
| 263 | |
| 264 /** | |
| 265 * analysis.setPriorityFiles params | |
| 266 * | |
| 267 * { | |
| 268 * "files": List<FilePath> | |
| 269 * } | |
| 270 */ | |
| 271 final Matcher isAnalysisSetPriorityFilesParams = new LazyMatcher(() => | |
| 272 new MatchesJsonObject( | |
| 273 "analysis.setPriorityFiles params", {"files": isListOf(isFilePath)})); | |
| 274 | |
| 275 /** | |
| 276 * analysis.setPriorityFiles result | |
| 277 */ | |
| 278 final Matcher isAnalysisSetPriorityFilesResult = isNull; | |
| 279 | |
| 280 /** | |
| 281 * analysis.setSubscriptions params | |
| 282 * | |
| 283 * { | |
| 284 * "subscriptions": Map<AnalysisService, List<FilePath>> | |
| 285 * } | |
| 286 */ | |
| 287 final Matcher isAnalysisSetSubscriptionsParams = new LazyMatcher(() => | |
| 288 new MatchesJsonObject("analysis.setSubscriptions params", | |
| 289 {"subscriptions": isMapOf(isAnalysisService, isListOf(isFilePath))})); | |
| 290 | |
| 291 /** | |
| 292 * analysis.setSubscriptions result | |
| 293 */ | |
| 294 final Matcher isAnalysisSetSubscriptionsResult = isNull; | |
| 295 | |
| 296 /** | |
| 297 * analysis.updateContent params | |
| 298 * | |
| 299 * { | |
| 300 * "files": Map<FilePath, AddContentOverlay | ChangeContentOverlay | RemoveCon
tentOverlay> | |
| 301 * } | |
| 302 */ | |
| 303 final Matcher isAnalysisUpdateContentParams = new LazyMatcher( | |
| 304 () => new MatchesJsonObject("analysis.updateContent params", { | |
| 305 "files": isMapOf( | |
| 306 isFilePath, | |
| 307 isOneOf([ | |
| 308 isAddContentOverlay, | |
| 309 isChangeContentOverlay, | |
| 310 isRemoveContentOverlay | |
| 311 ])) | |
| 312 })); | |
| 313 | |
| 314 /** | |
| 315 * analysis.updateContent result | |
| 316 * | |
| 317 * { | |
| 318 * } | |
| 319 */ | |
| 320 final Matcher isAnalysisUpdateContentResult = new LazyMatcher( | |
| 321 () => new MatchesJsonObject("analysis.updateContent result", null)); | |
| 322 | |
| 323 /** | |
| 324 * analysis.updateOptions params | |
| 325 * | |
| 326 * { | |
| 327 * "options": AnalysisOptions | |
| 328 * } | |
| 329 */ | |
| 330 final Matcher isAnalysisUpdateOptionsParams = new LazyMatcher(() => | |
| 331 new MatchesJsonObject( | |
| 332 "analysis.updateOptions params", {"options": isAnalysisOptions})); | |
| 333 | |
| 334 /** | |
| 335 * analysis.updateOptions result | |
| 336 */ | |
| 337 final Matcher isAnalysisUpdateOptionsResult = isNull; | |
| 338 | |
| 339 /** | |
| 340 * analysis.analyzedFiles params | |
| 341 * | |
| 342 * { | |
| 343 * "directories": List<FilePath> | |
| 344 * } | |
| 345 */ | |
| 346 final Matcher isAnalysisAnalyzedFilesParams = new LazyMatcher(() => | |
| 347 new MatchesJsonObject("analysis.analyzedFiles params", | |
| 348 {"directories": isListOf(isFilePath)})); | |
| 349 | |
| 350 /** | |
| 351 * analysis.errors params | |
| 352 * | |
| 353 * { | |
| 354 * "file": FilePath | |
| 355 * "errors": List<AnalysisError> | |
| 356 * } | |
| 357 */ | |
| 358 final Matcher isAnalysisErrorsParams = new LazyMatcher(() => | |
| 359 new MatchesJsonObject("analysis.errors params", | |
| 360 {"file": isFilePath, "errors": isListOf(isAnalysisError)})); | |
| 361 | |
| 362 /** | |
| 363 * analysis.flushResults params | |
| 364 * | |
| 365 * { | |
| 366 * "files": List<FilePath> | |
| 367 * } | |
| 368 */ | |
| 369 final Matcher isAnalysisFlushResultsParams = new LazyMatcher(() => | |
| 370 new MatchesJsonObject( | |
| 371 "analysis.flushResults params", {"files": isListOf(isFilePath)})); | |
| 372 | |
| 373 /** | |
| 374 * analysis.folding params | |
| 375 * | |
| 376 * { | |
| 377 * "file": FilePath | |
| 378 * "regions": List<FoldingRegion> | |
| 379 * } | |
| 380 */ | |
| 381 final Matcher isAnalysisFoldingParams = new LazyMatcher(() => | |
| 382 new MatchesJsonObject("analysis.folding params", | |
| 383 {"file": isFilePath, "regions": isListOf(isFoldingRegion)})); | |
| 384 | |
| 385 /** | |
| 386 * analysis.highlights params | |
| 387 * | |
| 388 * { | |
| 389 * "file": FilePath | |
| 390 * "regions": List<HighlightRegion> | |
| 391 * } | |
| 392 */ | |
| 393 final Matcher isAnalysisHighlightsParams = new LazyMatcher(() => | |
| 394 new MatchesJsonObject("analysis.highlights params", | |
| 395 {"file": isFilePath, "regions": isListOf(isHighlightRegion)})); | |
| 396 | |
| 397 /** | |
| 398 * analysis.implemented params | |
| 399 * | |
| 400 * { | |
| 401 * "file": FilePath | |
| 402 * "classes": List<ImplementedClass> | |
| 403 * "members": List<ImplementedMember> | |
| 404 * } | |
| 405 */ | |
| 406 final Matcher isAnalysisImplementedParams = | |
| 407 new LazyMatcher(() => new MatchesJsonObject("analysis.implemented params", { | |
| 408 "file": isFilePath, | |
| 409 "classes": isListOf(isImplementedClass), | |
| 410 "members": isListOf(isImplementedMember) | |
| 411 })); | |
| 412 | |
| 413 /** | |
| 414 * analysis.invalidate params | |
| 415 * | |
| 416 * { | |
| 417 * "file": FilePath | |
| 418 * "offset": int | |
| 419 * "length": int | |
| 420 * "delta": int | |
| 421 * } | |
| 422 */ | |
| 423 final Matcher isAnalysisInvalidateParams = new LazyMatcher(() => | |
| 424 new MatchesJsonObject("analysis.invalidate params", { | |
| 425 "file": isFilePath, | |
| 426 "offset": isInt, | |
| 427 "length": isInt, | |
| 428 "delta": isInt | |
| 429 })); | |
| 430 | |
| 431 /** | |
| 432 * analysis.navigation params | |
| 433 * | |
| 434 * { | |
| 435 * "file": FilePath | |
| 436 * "regions": List<NavigationRegion> | |
| 437 * "targets": List<NavigationTarget> | |
| 438 * "files": List<FilePath> | |
| 439 * } | |
| 440 */ | |
| 441 final Matcher isAnalysisNavigationParams = | |
| 442 new LazyMatcher(() => new MatchesJsonObject("analysis.navigation params", { | |
| 443 "file": isFilePath, | |
| 444 "regions": isListOf(isNavigationRegion), | |
| 445 "targets": isListOf(isNavigationTarget), | |
| 446 "files": isListOf(isFilePath) | |
| 447 })); | |
| 448 | |
| 449 /** | |
| 450 * analysis.occurrences params | |
| 451 * | |
| 452 * { | |
| 453 * "file": FilePath | |
| 454 * "occurrences": List<Occurrences> | |
| 455 * } | |
| 456 */ | |
| 457 final Matcher isAnalysisOccurrencesParams = new LazyMatcher(() => | |
| 458 new MatchesJsonObject("analysis.occurrences params", | |
| 459 {"file": isFilePath, "occurrences": isListOf(isOccurrences)})); | |
| 460 | |
| 461 /** | |
| 462 * analysis.outline params | |
| 463 * | |
| 464 * { | |
| 465 * "file": FilePath | |
| 466 * "kind": FileKind | |
| 467 * "libraryName": optional String | |
| 468 * "outline": Outline | |
| 469 * } | |
| 470 */ | |
| 471 final Matcher isAnalysisOutlineParams = new LazyMatcher(() => | |
| 472 new MatchesJsonObject("analysis.outline params", | |
| 473 {"file": isFilePath, "kind": isFileKind, "outline": isOutline}, | |
| 474 optionalFields: {"libraryName": isString})); | |
| 475 | |
| 476 /** | |
| 477 * analysis.overrides params | |
| 478 * | |
| 479 * { | |
| 480 * "file": FilePath | |
| 481 * "overrides": List<Override> | |
| 482 * } | |
| 483 */ | |
| 484 final Matcher isAnalysisOverridesParams = new LazyMatcher(() => | |
| 485 new MatchesJsonObject("analysis.overrides params", | |
| 486 {"file": isFilePath, "overrides": isListOf(isOverride)})); | |
| 487 | |
| 488 /** | |
| 489 * completion.getSuggestions params | |
| 490 * | |
| 491 * { | |
| 492 * "file": FilePath | |
| 493 * "offset": int | |
| 494 * } | |
| 495 */ | |
| 496 final Matcher isCompletionGetSuggestionsParams = new LazyMatcher(() => | |
| 497 new MatchesJsonObject("completion.getSuggestions params", | |
| 498 {"file": isFilePath, "offset": isInt})); | |
| 499 | |
| 500 /** | |
| 501 * completion.getSuggestions result | |
| 502 * | |
| 503 * { | |
| 504 * "id": CompletionId | |
| 505 * } | |
| 506 */ | |
| 507 final Matcher isCompletionGetSuggestionsResult = new LazyMatcher(() => | |
| 508 new MatchesJsonObject( | |
| 509 "completion.getSuggestions result", {"id": isCompletionId})); | |
| 510 | |
| 511 /** | |
| 512 * completion.results params | |
| 513 * | |
| 514 * { | |
| 515 * "id": CompletionId | |
| 516 * "replacementOffset": int | |
| 517 * "replacementLength": int | |
| 518 * "results": List<CompletionSuggestion> | |
| 519 * "isLast": bool | |
| 520 * } | |
| 521 */ | |
| 522 final Matcher isCompletionResultsParams = | |
| 523 new LazyMatcher(() => new MatchesJsonObject("completion.results params", { | |
| 524 "id": isCompletionId, | |
| 525 "replacementOffset": isInt, | |
| 526 "replacementLength": isInt, | |
| 527 "results": isListOf(isCompletionSuggestion), | |
| 528 "isLast": isBool | |
| 529 })); | |
| 530 | |
| 531 /** | |
| 532 * search.findElementReferences params | |
| 533 * | |
| 534 * { | |
| 535 * "file": FilePath | |
| 536 * "offset": int | |
| 537 * "includePotential": bool | |
| 538 * } | |
| 539 */ | |
| 540 final Matcher isSearchFindElementReferencesParams = new LazyMatcher(() => | |
| 541 new MatchesJsonObject("search.findElementReferences params", | |
| 542 {"file": isFilePath, "offset": isInt, "includePotential": isBool})); | |
| 543 | |
| 544 /** | |
| 545 * search.findElementReferences result | |
| 546 * | |
| 547 * { | |
| 548 * "id": optional SearchId | |
| 549 * "element": optional Element | |
| 550 * } | |
| 551 */ | |
| 552 final Matcher isSearchFindElementReferencesResult = new LazyMatcher(() => | |
| 553 new MatchesJsonObject("search.findElementReferences result", null, | |
| 554 optionalFields: {"id": isSearchId, "element": isElement})); | |
| 555 | |
| 556 /** | |
| 557 * search.findMemberDeclarations params | |
| 558 * | |
| 559 * { | |
| 560 * "name": String | |
| 561 * } | |
| 562 */ | |
| 563 final Matcher isSearchFindMemberDeclarationsParams = new LazyMatcher(() => | |
| 564 new MatchesJsonObject( | |
| 565 "search.findMemberDeclarations params", {"name": isString})); | |
| 566 | |
| 567 /** | |
| 568 * search.findMemberDeclarations result | |
| 569 * | |
| 570 * { | |
| 571 * "id": SearchId | |
| 572 * } | |
| 573 */ | |
| 574 final Matcher isSearchFindMemberDeclarationsResult = new LazyMatcher(() => | |
| 575 new MatchesJsonObject( | |
| 576 "search.findMemberDeclarations result", {"id": isSearchId})); | |
| 577 | |
| 578 /** | |
| 579 * search.findMemberReferences params | |
| 580 * | |
| 581 * { | |
| 582 * "name": String | |
| 583 * } | |
| 584 */ | |
| 585 final Matcher isSearchFindMemberReferencesParams = new LazyMatcher(() => | |
| 586 new MatchesJsonObject( | |
| 587 "search.findMemberReferences params", {"name": isString})); | |
| 588 | |
| 589 /** | |
| 590 * search.findMemberReferences result | |
| 591 * | |
| 592 * { | |
| 593 * "id": SearchId | |
| 594 * } | |
| 595 */ | |
| 596 final Matcher isSearchFindMemberReferencesResult = new LazyMatcher(() => | |
| 597 new MatchesJsonObject( | |
| 598 "search.findMemberReferences result", {"id": isSearchId})); | |
| 599 | |
| 600 /** | |
| 601 * search.findTopLevelDeclarations params | |
| 602 * | |
| 603 * { | |
| 604 * "pattern": String | |
| 605 * } | |
| 606 */ | |
| 607 final Matcher isSearchFindTopLevelDeclarationsParams = new LazyMatcher(() => | |
| 608 new MatchesJsonObject( | |
| 609 "search.findTopLevelDeclarations params", {"pattern": isString})); | |
| 610 | |
| 611 /** | |
| 612 * search.findTopLevelDeclarations result | |
| 613 * | |
| 614 * { | |
| 615 * "id": SearchId | |
| 616 * } | |
| 617 */ | |
| 618 final Matcher isSearchFindTopLevelDeclarationsResult = new LazyMatcher(() => | |
| 619 new MatchesJsonObject( | |
| 620 "search.findTopLevelDeclarations result", {"id": isSearchId})); | |
| 621 | |
| 622 /** | |
| 623 * search.getTypeHierarchy params | |
| 624 * | |
| 625 * { | |
| 626 * "file": FilePath | |
| 627 * "offset": int | |
| 628 * "superOnly": optional bool | |
| 629 * } | |
| 630 */ | |
| 631 final Matcher isSearchGetTypeHierarchyParams = new LazyMatcher(() => | |
| 632 new MatchesJsonObject( | |
| 633 "search.getTypeHierarchy params", {"file": isFilePath, "offset": isInt}, | |
| 634 optionalFields: {"superOnly": isBool})); | |
| 635 | |
| 636 /** | |
| 637 * search.getTypeHierarchy result | |
| 638 * | |
| 639 * { | |
| 640 * "hierarchyItems": optional List<TypeHierarchyItem> | |
| 641 * } | |
| 642 */ | |
| 643 final Matcher isSearchGetTypeHierarchyResult = new LazyMatcher(() => | |
| 644 new MatchesJsonObject("search.getTypeHierarchy result", null, | |
| 645 optionalFields: {"hierarchyItems": isListOf(isTypeHierarchyItem)})); | |
| 646 | |
| 647 /** | |
| 648 * search.results params | |
| 649 * | |
| 650 * { | |
| 651 * "id": SearchId | |
| 652 * "results": List<SearchResult> | |
| 653 * "isLast": bool | |
| 654 * } | |
| 655 */ | |
| 656 final Matcher isSearchResultsParams = new LazyMatcher(() => | |
| 657 new MatchesJsonObject("search.results params", { | |
| 658 "id": isSearchId, | |
| 659 "results": isListOf(isSearchResult), | |
| 660 "isLast": isBool | |
| 661 })); | |
| 662 | |
| 663 /** | |
| 664 * edit.format params | |
| 665 * | |
| 666 * { | |
| 667 * "file": FilePath | |
| 668 * "selectionOffset": int | |
| 669 * "selectionLength": int | |
| 670 * "lineLength": optional int | |
| 671 * } | |
| 672 */ | |
| 673 final Matcher isEditFormatParams = new LazyMatcher(() => new MatchesJsonObject( | |
| 674 "edit.format params", | |
| 675 {"file": isFilePath, "selectionOffset": isInt, "selectionLength": isInt}, | |
| 676 optionalFields: {"lineLength": isInt})); | |
| 677 | |
| 678 /** | |
| 679 * edit.format result | |
| 680 * | |
| 681 * { | |
| 682 * "edits": List<SourceEdit> | |
| 683 * "selectionOffset": int | |
| 684 * "selectionLength": int | |
| 685 * } | |
| 686 */ | |
| 687 final Matcher isEditFormatResult = | |
| 688 new LazyMatcher(() => new MatchesJsonObject("edit.format result", { | |
| 689 "edits": isListOf(isSourceEdit), | |
| 690 "selectionOffset": isInt, | |
| 691 "selectionLength": isInt | |
| 692 })); | |
| 693 | |
| 694 /** | |
| 695 * edit.getAssists params | |
| 696 * | |
| 697 * { | |
| 698 * "file": FilePath | |
| 699 * "offset": int | |
| 700 * "length": int | |
| 701 * } | |
| 702 */ | |
| 703 final Matcher isEditGetAssistsParams = new LazyMatcher(() => | |
| 704 new MatchesJsonObject("edit.getAssists params", | |
| 705 {"file": isFilePath, "offset": isInt, "length": isInt})); | |
| 706 | |
| 707 /** | |
| 708 * edit.getAssists result | |
| 709 * | |
| 710 * { | |
| 711 * "assists": List<SourceChange> | |
| 712 * } | |
| 713 */ | |
| 714 final Matcher isEditGetAssistsResult = new LazyMatcher(() => | |
| 715 new MatchesJsonObject( | |
| 716 "edit.getAssists result", {"assists": isListOf(isSourceChange)})); | |
| 717 | |
| 718 /** | |
| 719 * edit.getAvailableRefactorings params | |
| 720 * | |
| 721 * { | |
| 722 * "file": FilePath | |
| 723 * "offset": int | |
| 724 * "length": int | |
| 725 * } | |
| 726 */ | |
| 727 final Matcher isEditGetAvailableRefactoringsParams = new LazyMatcher(() => | |
| 728 new MatchesJsonObject("edit.getAvailableRefactorings params", | |
| 729 {"file": isFilePath, "offset": isInt, "length": isInt})); | |
| 730 | |
| 731 /** | |
| 732 * edit.getAvailableRefactorings result | |
| 733 * | |
| 734 * { | |
| 735 * "kinds": List<RefactoringKind> | |
| 736 * } | |
| 737 */ | |
| 738 final Matcher isEditGetAvailableRefactoringsResult = new LazyMatcher(() => | |
| 739 new MatchesJsonObject("edit.getAvailableRefactorings result", | |
| 740 {"kinds": isListOf(isRefactoringKind)})); | |
| 741 | |
| 742 /** | |
| 743 * edit.getFixes params | |
| 744 * | |
| 745 * { | |
| 746 * "file": FilePath | |
| 747 * "offset": int | |
| 748 * } | |
| 749 */ | |
| 750 final Matcher isEditGetFixesParams = new LazyMatcher(() => | |
| 751 new MatchesJsonObject( | |
| 752 "edit.getFixes params", {"file": isFilePath, "offset": isInt})); | |
| 753 | |
| 754 /** | |
| 755 * edit.getFixes result | |
| 756 * | |
| 757 * { | |
| 758 * "fixes": List<AnalysisErrorFixes> | |
| 759 * } | |
| 760 */ | |
| 761 final Matcher isEditGetFixesResult = new LazyMatcher(() => | |
| 762 new MatchesJsonObject( | |
| 763 "edit.getFixes result", {"fixes": isListOf(isAnalysisErrorFixes)})); | |
| 764 | |
| 765 /** | |
| 766 * edit.getRefactoring params | |
| 767 * | |
| 768 * { | |
| 769 * "kind": RefactoringKind | |
| 770 * "file": FilePath | |
| 771 * "offset": int | |
| 772 * "length": int | |
| 773 * "validateOnly": bool | |
| 774 * "options": optional RefactoringOptions | |
| 775 * } | |
| 776 */ | |
| 777 final Matcher isEditGetRefactoringParams = | |
| 778 new LazyMatcher(() => new MatchesJsonObject("edit.getRefactoring params", { | |
| 779 "kind": isRefactoringKind, | |
| 780 "file": isFilePath, | |
| 781 "offset": isInt, | |
| 782 "length": isInt, | |
| 783 "validateOnly": isBool | |
| 784 }, optionalFields: { | |
| 785 "options": isRefactoringOptions | |
| 786 })); | |
| 787 | |
| 788 /** | |
| 789 * edit.getRefactoring result | |
| 790 * | |
| 791 * { | |
| 792 * "initialProblems": List<RefactoringProblem> | |
| 793 * "optionsProblems": List<RefactoringProblem> | |
| 794 * "finalProblems": List<RefactoringProblem> | |
| 795 * "feedback": optional RefactoringFeedback | |
| 796 * "change": optional SourceChange | |
| 797 * "potentialEdits": optional List<String> | |
| 798 * } | |
| 799 */ | |
| 800 final Matcher isEditGetRefactoringResult = | |
| 801 new LazyMatcher(() => new MatchesJsonObject("edit.getRefactoring result", { | |
| 802 "initialProblems": isListOf(isRefactoringProblem), | |
| 803 "optionsProblems": isListOf(isRefactoringProblem), | |
| 804 "finalProblems": isListOf(isRefactoringProblem) | |
| 805 }, optionalFields: { | |
| 806 "feedback": isRefactoringFeedback, | |
| 807 "change": isSourceChange, | |
| 808 "potentialEdits": isListOf(isString) | |
| 809 })); | |
| 810 | |
| 811 /** | |
| 812 * edit.getStatementCompletion params | |
| 813 * | |
| 814 * { | |
| 815 * "file": FilePath | |
| 816 * "offset": int | |
| 817 * } | |
| 818 */ | |
| 819 final Matcher isEditGetStatementCompletionParams = new LazyMatcher(() => | |
| 820 new MatchesJsonObject("edit.getStatementCompletion params", | |
| 821 {"file": isFilePath, "offset": isInt})); | |
| 822 | |
| 823 /** | |
| 824 * edit.getStatementCompletion result | |
| 825 * | |
| 826 * { | |
| 827 * "change": SourceChange | |
| 828 * "whitespaceOnly": bool | |
| 829 * } | |
| 830 */ | |
| 831 final Matcher isEditGetStatementCompletionResult = new LazyMatcher(() => | |
| 832 new MatchesJsonObject("edit.getStatementCompletion result", | |
| 833 {"change": isSourceChange, "whitespaceOnly": isBool})); | |
| 834 | |
| 835 /** | |
| 836 * edit.sortMembers params | |
| 837 * | |
| 838 * { | |
| 839 * "file": FilePath | |
| 840 * } | |
| 841 */ | |
| 842 final Matcher isEditSortMembersParams = new LazyMatcher(() => | |
| 843 new MatchesJsonObject("edit.sortMembers params", {"file": isFilePath})); | |
| 844 | |
| 845 /** | |
| 846 * edit.sortMembers result | |
| 847 * | |
| 848 * { | |
| 849 * "edit": SourceFileEdit | |
| 850 * } | |
| 851 */ | |
| 852 final Matcher isEditSortMembersResult = new LazyMatcher(() => | |
| 853 new MatchesJsonObject( | |
| 854 "edit.sortMembers result", {"edit": isSourceFileEdit})); | |
| 855 | |
| 856 /** | |
| 857 * edit.organizeDirectives params | |
| 858 * | |
| 859 * { | |
| 860 * "file": FilePath | |
| 861 * } | |
| 862 */ | |
| 863 final Matcher isEditOrganizeDirectivesParams = new LazyMatcher(() => | |
| 864 new MatchesJsonObject( | |
| 865 "edit.organizeDirectives params", {"file": isFilePath})); | |
| 866 | |
| 867 /** | |
| 868 * edit.organizeDirectives result | |
| 869 * | |
| 870 * { | |
| 871 * "edit": SourceFileEdit | |
| 872 * } | |
| 873 */ | |
| 874 final Matcher isEditOrganizeDirectivesResult = new LazyMatcher(() => | |
| 875 new MatchesJsonObject( | |
| 876 "edit.organizeDirectives result", {"edit": isSourceFileEdit})); | |
| 877 | |
| 878 /** | |
| 879 * execution.createContext params | |
| 880 * | |
| 881 * { | |
| 882 * "contextRoot": FilePath | |
| 883 * } | |
| 884 */ | |
| 885 final Matcher isExecutionCreateContextParams = new LazyMatcher(() => | |
| 886 new MatchesJsonObject( | |
| 887 "execution.createContext params", {"contextRoot": isFilePath})); | |
| 888 | |
| 889 /** | |
| 890 * execution.createContext result | |
| 891 * | |
| 892 * { | |
| 893 * "id": ExecutionContextId | |
| 894 * } | |
| 895 */ | |
| 896 final Matcher isExecutionCreateContextResult = new LazyMatcher(() => | |
| 897 new MatchesJsonObject( | |
| 898 "execution.createContext result", {"id": isExecutionContextId})); | |
| 899 | |
| 900 /** | |
| 901 * execution.deleteContext params | |
| 902 * | |
| 903 * { | |
| 904 * "id": ExecutionContextId | |
| 905 * } | |
| 906 */ | |
| 907 final Matcher isExecutionDeleteContextParams = new LazyMatcher(() => | |
| 908 new MatchesJsonObject( | |
| 909 "execution.deleteContext params", {"id": isExecutionContextId})); | |
| 910 | |
| 911 /** | |
| 912 * execution.deleteContext result | |
| 913 */ | |
| 914 final Matcher isExecutionDeleteContextResult = isNull; | |
| 915 | |
| 916 /** | |
| 917 * execution.mapUri params | |
| 918 * | |
| 919 * { | |
| 920 * "id": ExecutionContextId | |
| 921 * "file": optional FilePath | |
| 922 * "uri": optional String | |
| 923 * } | |
| 924 */ | |
| 925 final Matcher isExecutionMapUriParams = new LazyMatcher(() => | |
| 926 new MatchesJsonObject( | |
| 927 "execution.mapUri params", {"id": isExecutionContextId}, | |
| 928 optionalFields: {"file": isFilePath, "uri": isString})); | |
| 929 | |
| 930 /** | |
| 931 * execution.mapUri result | |
| 932 * | |
| 933 * { | |
| 934 * "file": optional FilePath | |
| 935 * "uri": optional String | |
| 936 * } | |
| 937 */ | |
| 938 final Matcher isExecutionMapUriResult = new LazyMatcher(() => | |
| 939 new MatchesJsonObject("execution.mapUri result", null, | |
| 940 optionalFields: {"file": isFilePath, "uri": isString})); | |
| 941 | |
| 942 /** | |
| 943 * execution.setSubscriptions params | |
| 944 * | |
| 945 * { | |
| 946 * "subscriptions": List<ExecutionService> | |
| 947 * } | |
| 948 */ | |
| 949 final Matcher isExecutionSetSubscriptionsParams = new LazyMatcher(() => | |
| 950 new MatchesJsonObject("execution.setSubscriptions params", | |
| 951 {"subscriptions": isListOf(isExecutionService)})); | |
| 952 | |
| 953 /** | |
| 954 * execution.setSubscriptions result | |
| 955 */ | |
| 956 final Matcher isExecutionSetSubscriptionsResult = isNull; | |
| 957 | |
| 958 /** | |
| 959 * execution.launchData params | |
| 960 * | |
| 961 * { | |
| 962 * "file": FilePath | |
| 963 * "kind": optional ExecutableKind | |
| 964 * "referencedFiles": optional List<FilePath> | |
| 965 * } | |
| 966 */ | |
| 967 final Matcher isExecutionLaunchDataParams = new LazyMatcher(() => | |
| 968 new MatchesJsonObject("execution.launchData params", { | |
| 969 "file": isFilePath | |
| 970 }, optionalFields: { | |
| 971 "kind": isExecutableKind, | |
| 972 "referencedFiles": isListOf(isFilePath) | |
| 973 })); | |
| 974 | |
| 975 /** | |
| 976 * diagnostic.getDiagnostics params | |
| 977 */ | |
| 978 final Matcher isDiagnosticGetDiagnosticsParams = isNull; | |
| 979 | |
| 980 /** | |
| 981 * diagnostic.getDiagnostics result | |
| 982 * | |
| 983 * { | |
| 984 * "contexts": List<ContextData> | |
| 985 * } | |
| 986 */ | |
| 987 final Matcher isDiagnosticGetDiagnosticsResult = new LazyMatcher(() => | |
| 988 new MatchesJsonObject("diagnostic.getDiagnostics result", | |
| 989 {"contexts": isListOf(isContextData)})); | |
| 990 | |
| 991 /** | |
| 992 * diagnostic.getServerPort params | |
| 993 */ | |
| 994 final Matcher isDiagnosticGetServerPortParams = isNull; | |
| 995 | |
| 996 /** | |
| 997 * diagnostic.getServerPort result | |
| 998 * | |
| 999 * { | |
| 1000 * "port": int | |
| 1001 * } | |
| 1002 */ | |
| 1003 final Matcher isDiagnosticGetServerPortResult = new LazyMatcher(() => | |
| 1004 new MatchesJsonObject("diagnostic.getServerPort result", {"port": isInt})); | |
| 1005 | |
| 1006 /** | |
| 1007 * AddContentOverlay | |
| 1008 * | |
| 1009 * { | |
| 1010 * "type": "add" | |
| 1011 * "content": String | |
| 1012 * } | |
| 1013 */ | |
| 1014 final Matcher isAddContentOverlay = new LazyMatcher(() => new MatchesJsonObject( | |
| 1015 "AddContentOverlay", {"type": equals("add"), "content": isString})); | |
| 1016 | |
| 1017 /** | |
| 1018 * AnalysisError | |
| 1019 * | |
| 1020 * { | |
| 1021 * "severity": AnalysisErrorSeverity | |
| 1022 * "type": AnalysisErrorType | |
| 1023 * "location": Location | |
| 1024 * "message": String | |
| 1025 * "correction": optional String | |
| 1026 * "code": String | |
| 1027 * "hasFix": optional bool | |
| 1028 * } | |
| 1029 */ | |
| 1030 final Matcher isAnalysisError = | |
| 1031 new LazyMatcher(() => new MatchesJsonObject("AnalysisError", { | |
| 1032 "severity": isAnalysisErrorSeverity, | |
| 1033 "type": isAnalysisErrorType, | |
| 1034 "location": isLocation, | |
| 1035 "message": isString, | |
| 1036 "code": isString | |
| 1037 }, optionalFields: { | |
| 1038 "correction": isString, | |
| 1039 "hasFix": isBool | |
| 1040 })); | |
| 1041 | |
| 1042 /** | |
| 1043 * AnalysisErrorFixes | |
| 1044 * | |
| 1045 * { | |
| 1046 * "error": AnalysisError | |
| 1047 * "fixes": List<SourceChange> | |
| 1048 * } | |
| 1049 */ | |
| 1050 final Matcher isAnalysisErrorFixes = new LazyMatcher(() => | |
| 1051 new MatchesJsonObject("AnalysisErrorFixes", | |
| 1052 {"error": isAnalysisError, "fixes": isListOf(isSourceChange)})); | |
| 1053 | |
| 1054 /** | |
| 1055 * AnalysisErrorSeverity | |
| 1056 * | |
| 1057 * enum { | |
| 1058 * INFO | |
| 1059 * WARNING | |
| 1060 * ERROR | |
| 1061 * } | |
| 1062 */ | |
| 1063 final Matcher isAnalysisErrorSeverity = | |
| 1064 new MatchesEnum("AnalysisErrorSeverity", ["INFO", "WARNING", "ERROR"]); | |
| 1065 | |
| 1066 /** | |
| 1067 * AnalysisErrorType | |
| 1068 * | |
| 1069 * enum { | |
| 1070 * CHECKED_MODE_COMPILE_TIME_ERROR | |
| 1071 * COMPILE_TIME_ERROR | |
| 1072 * HINT | |
| 1073 * LINT | |
| 1074 * STATIC_TYPE_WARNING | |
| 1075 * STATIC_WARNING | |
| 1076 * SYNTACTIC_ERROR | |
| 1077 * TODO | |
| 1078 * } | |
| 1079 */ | |
| 1080 final Matcher isAnalysisErrorType = new MatchesEnum("AnalysisErrorType", [ | |
| 1081 "CHECKED_MODE_COMPILE_TIME_ERROR", | |
| 1082 "COMPILE_TIME_ERROR", | |
| 1083 "HINT", | |
| 1084 "LINT", | |
| 1085 "STATIC_TYPE_WARNING", | |
| 1086 "STATIC_WARNING", | |
| 1087 "SYNTACTIC_ERROR", | |
| 1088 "TODO" | |
| 1089 ]); | |
| 1090 | |
| 1091 /** | |
| 1092 * AnalysisOptions | |
| 1093 * | |
| 1094 * { | |
| 1095 * "enableAsync": optional bool | |
| 1096 * "enableDeferredLoading": optional bool | |
| 1097 * "enableEnums": optional bool | |
| 1098 * "enableNullAwareOperators": optional bool | |
| 1099 * "enableSuperMixins": optional bool | |
| 1100 * "generateDart2jsHints": optional bool | |
| 1101 * "generateHints": optional bool | |
| 1102 * "generateLints": optional bool | |
| 1103 * } | |
| 1104 */ | |
| 1105 final Matcher isAnalysisOptions = new LazyMatcher( | |
| 1106 () => new MatchesJsonObject("AnalysisOptions", null, optionalFields: { | |
| 1107 "enableAsync": isBool, | |
| 1108 "enableDeferredLoading": isBool, | |
| 1109 "enableEnums": isBool, | |
| 1110 "enableNullAwareOperators": isBool, | |
| 1111 "enableSuperMixins": isBool, | |
| 1112 "generateDart2jsHints": isBool, | |
| 1113 "generateHints": isBool, | |
| 1114 "generateLints": isBool | |
| 1115 })); | |
| 1116 | |
| 1117 /** | |
| 1118 * AnalysisService | |
| 1119 * | |
| 1120 * enum { | |
| 1121 * FOLDING | |
| 1122 * HIGHLIGHTS | |
| 1123 * IMPLEMENTED | |
| 1124 * INVALIDATE | |
| 1125 * NAVIGATION | |
| 1126 * OCCURRENCES | |
| 1127 * OUTLINE | |
| 1128 * OVERRIDES | |
| 1129 * } | |
| 1130 */ | |
| 1131 final Matcher isAnalysisService = new MatchesEnum("AnalysisService", [ | |
| 1132 "FOLDING", | |
| 1133 "HIGHLIGHTS", | |
| 1134 "IMPLEMENTED", | |
| 1135 "INVALIDATE", | |
| 1136 "NAVIGATION", | |
| 1137 "OCCURRENCES", | |
| 1138 "OUTLINE", | |
| 1139 "OVERRIDES" | |
| 1140 ]); | |
| 1141 | |
| 1142 /** | |
| 1143 * AnalysisStatus | |
| 1144 * | |
| 1145 * { | |
| 1146 * "isAnalyzing": bool | |
| 1147 * "analysisTarget": optional String | |
| 1148 * } | |
| 1149 */ | |
| 1150 final Matcher isAnalysisStatus = new LazyMatcher(() => new MatchesJsonObject( | |
| 1151 "AnalysisStatus", {"isAnalyzing": isBool}, | |
| 1152 optionalFields: {"analysisTarget": isString})); | |
| 1153 | |
| 1154 /** | |
| 1155 * ChangeContentOverlay | |
| 1156 * | |
| 1157 * { | |
| 1158 * "type": "change" | |
| 1159 * "edits": List<SourceEdit> | |
| 1160 * } | |
| 1161 */ | |
| 1162 final Matcher isChangeContentOverlay = new LazyMatcher(() => | |
| 1163 new MatchesJsonObject("ChangeContentOverlay", | |
| 1164 {"type": equals("change"), "edits": isListOf(isSourceEdit)})); | |
| 1165 | |
| 1166 /** | |
| 1167 * CompletionId | |
| 1168 * | |
| 1169 * String | |
| 1170 */ | |
| 1171 final Matcher isCompletionId = isString; | |
| 1172 | |
| 1173 /** | |
| 1174 * CompletionSuggestion | |
| 1175 * | |
| 1176 * { | |
| 1177 * "kind": CompletionSuggestionKind | |
| 1178 * "relevance": int | |
| 1179 * "completion": String | |
| 1180 * "selectionOffset": int | |
| 1181 * "selectionLength": int | |
| 1182 * "isDeprecated": bool | |
| 1183 * "isPotential": bool | |
| 1184 * "docSummary": optional String | |
| 1185 * "docComplete": optional String | |
| 1186 * "declaringType": optional String | |
| 1187 * "defaultArgumentListString": optional String | |
| 1188 * "defaultArgumentListTextRanges": optional List<int> | |
| 1189 * "element": optional Element | |
| 1190 * "returnType": optional String | |
| 1191 * "parameterNames": optional List<String> | |
| 1192 * "parameterTypes": optional List<String> | |
| 1193 * "requiredParameterCount": optional int | |
| 1194 * "hasNamedParameters": optional bool | |
| 1195 * "parameterName": optional String | |
| 1196 * "parameterType": optional String | |
| 1197 * "importUri": optional String | |
| 1198 * } | |
| 1199 */ | |
| 1200 final Matcher isCompletionSuggestion = | |
| 1201 new LazyMatcher(() => new MatchesJsonObject("CompletionSuggestion", { | |
| 1202 "kind": isCompletionSuggestionKind, | |
| 1203 "relevance": isInt, | |
| 1204 "completion": isString, | |
| 1205 "selectionOffset": isInt, | |
| 1206 "selectionLength": isInt, | |
| 1207 "isDeprecated": isBool, | |
| 1208 "isPotential": isBool | |
| 1209 }, optionalFields: { | |
| 1210 "docSummary": isString, | |
| 1211 "docComplete": isString, | |
| 1212 "declaringType": isString, | |
| 1213 "defaultArgumentListString": isString, | |
| 1214 "defaultArgumentListTextRanges": isListOf(isInt), | |
| 1215 "element": isElement, | |
| 1216 "returnType": isString, | |
| 1217 "parameterNames": isListOf(isString), | |
| 1218 "parameterTypes": isListOf(isString), | |
| 1219 "requiredParameterCount": isInt, | |
| 1220 "hasNamedParameters": isBool, | |
| 1221 "parameterName": isString, | |
| 1222 "parameterType": isString, | |
| 1223 "importUri": isString | |
| 1224 })); | |
| 1225 | |
| 1226 /** | |
| 1227 * CompletionSuggestionKind | |
| 1228 * | |
| 1229 * enum { | |
| 1230 * ARGUMENT_LIST | |
| 1231 * IMPORT | |
| 1232 * IDENTIFIER | |
| 1233 * INVOCATION | |
| 1234 * KEYWORD | |
| 1235 * NAMED_ARGUMENT | |
| 1236 * OPTIONAL_ARGUMENT | |
| 1237 * PARAMETER | |
| 1238 * } | |
| 1239 */ | |
| 1240 final Matcher isCompletionSuggestionKind = | |
| 1241 new MatchesEnum("CompletionSuggestionKind", [ | |
| 1242 "ARGUMENT_LIST", | |
| 1243 "IMPORT", | |
| 1244 "IDENTIFIER", | |
| 1245 "INVOCATION", | |
| 1246 "KEYWORD", | |
| 1247 "NAMED_ARGUMENT", | |
| 1248 "OPTIONAL_ARGUMENT", | |
| 1249 "PARAMETER" | |
| 1250 ]); | |
| 1251 | |
| 1252 /** | |
| 1253 * ContextData | |
| 1254 * | |
| 1255 * { | |
| 1256 * "name": String | |
| 1257 * "explicitFileCount": int | |
| 1258 * "implicitFileCount": int | |
| 1259 * "workItemQueueLength": int | |
| 1260 * "cacheEntryExceptions": List<String> | |
| 1261 * } | |
| 1262 */ | |
| 1263 final Matcher isContextData = | |
| 1264 new LazyMatcher(() => new MatchesJsonObject("ContextData", { | |
| 1265 "name": isString, | |
| 1266 "explicitFileCount": isInt, | |
| 1267 "implicitFileCount": isInt, | |
| 1268 "workItemQueueLength": isInt, | |
| 1269 "cacheEntryExceptions": isListOf(isString) | |
| 1270 })); | |
| 1271 | |
| 1272 /** | |
| 1273 * Element | |
| 1274 * | |
| 1275 * { | |
| 1276 * "kind": ElementKind | |
| 1277 * "name": String | |
| 1278 * "location": optional Location | |
| 1279 * "flags": int | |
| 1280 * "parameters": optional String | |
| 1281 * "returnType": optional String | |
| 1282 * "typeParameters": optional String | |
| 1283 * } | |
| 1284 */ | |
| 1285 final Matcher isElement = | |
| 1286 new LazyMatcher(() => new MatchesJsonObject("Element", { | |
| 1287 "kind": isElementKind, | |
| 1288 "name": isString, | |
| 1289 "flags": isInt | |
| 1290 }, optionalFields: { | |
| 1291 "location": isLocation, | |
| 1292 "parameters": isString, | |
| 1293 "returnType": isString, | |
| 1294 "typeParameters": isString | |
| 1295 })); | |
| 1296 | |
| 1297 /** | |
| 1298 * ElementKind | |
| 1299 * | |
| 1300 * enum { | |
| 1301 * CLASS | |
| 1302 * CLASS_TYPE_ALIAS | |
| 1303 * COMPILATION_UNIT | |
| 1304 * CONSTRUCTOR | |
| 1305 * ENUM | |
| 1306 * ENUM_CONSTANT | |
| 1307 * FIELD | |
| 1308 * FILE | |
| 1309 * FUNCTION | |
| 1310 * FUNCTION_TYPE_ALIAS | |
| 1311 * GETTER | |
| 1312 * LABEL | |
| 1313 * LIBRARY | |
| 1314 * LOCAL_VARIABLE | |
| 1315 * METHOD | |
| 1316 * PARAMETER | |
| 1317 * PREFIX | |
| 1318 * SETTER | |
| 1319 * TOP_LEVEL_VARIABLE | |
| 1320 * TYPE_PARAMETER | |
| 1321 * UNIT_TEST_GROUP | |
| 1322 * UNIT_TEST_TEST | |
| 1323 * UNKNOWN | |
| 1324 * } | |
| 1325 */ | |
| 1326 final Matcher isElementKind = new MatchesEnum("ElementKind", [ | |
| 1327 "CLASS", | |
| 1328 "CLASS_TYPE_ALIAS", | |
| 1329 "COMPILATION_UNIT", | |
| 1330 "CONSTRUCTOR", | |
| 1331 "ENUM", | |
| 1332 "ENUM_CONSTANT", | |
| 1333 "FIELD", | |
| 1334 "FILE", | |
| 1335 "FUNCTION", | |
| 1336 "FUNCTION_TYPE_ALIAS", | |
| 1337 "GETTER", | |
| 1338 "LABEL", | |
| 1339 "LIBRARY", | |
| 1340 "LOCAL_VARIABLE", | |
| 1341 "METHOD", | |
| 1342 "PARAMETER", | |
| 1343 "PREFIX", | |
| 1344 "SETTER", | |
| 1345 "TOP_LEVEL_VARIABLE", | |
| 1346 "TYPE_PARAMETER", | |
| 1347 "UNIT_TEST_GROUP", | |
| 1348 "UNIT_TEST_TEST", | |
| 1349 "UNKNOWN" | |
| 1350 ]); | |
| 1351 | |
| 1352 /** | |
| 1353 * ExecutableFile | |
| 1354 * | |
| 1355 * { | |
| 1356 * "file": FilePath | |
| 1357 * "kind": ExecutableKind | |
| 1358 * } | |
| 1359 */ | |
| 1360 final Matcher isExecutableFile = new LazyMatcher(() => new MatchesJsonObject( | |
| 1361 "ExecutableFile", {"file": isFilePath, "kind": isExecutableKind})); | |
| 1362 | |
| 1363 /** | |
| 1364 * ExecutableKind | |
| 1365 * | |
| 1366 * enum { | |
| 1367 * CLIENT | |
| 1368 * EITHER | |
| 1369 * NOT_EXECUTABLE | |
| 1370 * SERVER | |
| 1371 * } | |
| 1372 */ | |
| 1373 final Matcher isExecutableKind = new MatchesEnum( | |
| 1374 "ExecutableKind", ["CLIENT", "EITHER", "NOT_EXECUTABLE", "SERVER"]); | |
| 1375 | |
| 1376 /** | |
| 1377 * ExecutionContextId | |
| 1378 * | |
| 1379 * String | |
| 1380 */ | |
| 1381 final Matcher isExecutionContextId = isString; | |
| 1382 | |
| 1383 /** | |
| 1384 * ExecutionService | |
| 1385 * | |
| 1386 * enum { | |
| 1387 * LAUNCH_DATA | |
| 1388 * } | |
| 1389 */ | |
| 1390 final Matcher isExecutionService = | |
| 1391 new MatchesEnum("ExecutionService", ["LAUNCH_DATA"]); | |
| 1392 | |
| 1393 /** | |
| 1394 * FileKind | |
| 1395 * | |
| 1396 * enum { | |
| 1397 * LIBRARY | |
| 1398 * PART | |
| 1399 * } | |
| 1400 */ | |
| 1401 final Matcher isFileKind = new MatchesEnum("FileKind", ["LIBRARY", "PART"]); | |
| 1402 | |
| 1403 /** | |
| 1404 * FilePath | |
| 1405 * | |
| 1406 * String | |
| 1407 */ | |
| 1408 final Matcher isFilePath = isString; | |
| 1409 | |
| 1410 /** | |
| 1411 * FoldingKind | |
| 1412 * | |
| 1413 * enum { | |
| 1414 * COMMENT | |
| 1415 * CLASS_MEMBER | |
| 1416 * DIRECTIVES | |
| 1417 * DOCUMENTATION_COMMENT | |
| 1418 * TOP_LEVEL_DECLARATION | |
| 1419 * } | |
| 1420 */ | |
| 1421 final Matcher isFoldingKind = new MatchesEnum("FoldingKind", [ | |
| 1422 "COMMENT", | |
| 1423 "CLASS_MEMBER", | |
| 1424 "DIRECTIVES", | |
| 1425 "DOCUMENTATION_COMMENT", | |
| 1426 "TOP_LEVEL_DECLARATION" | |
| 1427 ]); | |
| 1428 | |
| 1429 /** | |
| 1430 * FoldingRegion | |
| 1431 * | |
| 1432 * { | |
| 1433 * "kind": FoldingKind | |
| 1434 * "offset": int | |
| 1435 * "length": int | |
| 1436 * } | |
| 1437 */ | |
| 1438 final Matcher isFoldingRegion = new LazyMatcher(() => new MatchesJsonObject( | |
| 1439 "FoldingRegion", | |
| 1440 {"kind": isFoldingKind, "offset": isInt, "length": isInt})); | |
| 1441 | |
| 1442 /** | |
| 1443 * GeneralAnalysisService | |
| 1444 * | |
| 1445 * enum { | |
| 1446 * ANALYZED_FILES | |
| 1447 * } | |
| 1448 */ | |
| 1449 final Matcher isGeneralAnalysisService = | |
| 1450 new MatchesEnum("GeneralAnalysisService", ["ANALYZED_FILES"]); | |
| 1451 | |
| 1452 /** | |
| 1453 * HighlightRegion | |
| 1454 * | |
| 1455 * { | |
| 1456 * "type": HighlightRegionType | |
| 1457 * "offset": int | |
| 1458 * "length": int | |
| 1459 * } | |
| 1460 */ | |
| 1461 final Matcher isHighlightRegion = new LazyMatcher(() => new MatchesJsonObject( | |
| 1462 "HighlightRegion", | |
| 1463 {"type": isHighlightRegionType, "offset": isInt, "length": isInt})); | |
| 1464 | |
| 1465 /** | |
| 1466 * HighlightRegionType | |
| 1467 * | |
| 1468 * enum { | |
| 1469 * ANNOTATION | |
| 1470 * BUILT_IN | |
| 1471 * CLASS | |
| 1472 * COMMENT_BLOCK | |
| 1473 * COMMENT_DOCUMENTATION | |
| 1474 * COMMENT_END_OF_LINE | |
| 1475 * CONSTRUCTOR | |
| 1476 * DIRECTIVE | |
| 1477 * DYNAMIC_TYPE | |
| 1478 * DYNAMIC_LOCAL_VARIABLE_DECLARATION | |
| 1479 * DYNAMIC_LOCAL_VARIABLE_REFERENCE | |
| 1480 * DYNAMIC_PARAMETER_DECLARATION | |
| 1481 * DYNAMIC_PARAMETER_REFERENCE | |
| 1482 * ENUM | |
| 1483 * ENUM_CONSTANT | |
| 1484 * FIELD | |
| 1485 * FIELD_STATIC | |
| 1486 * FUNCTION | |
| 1487 * FUNCTION_DECLARATION | |
| 1488 * FUNCTION_TYPE_ALIAS | |
| 1489 * GETTER_DECLARATION | |
| 1490 * IDENTIFIER_DEFAULT | |
| 1491 * IMPORT_PREFIX | |
| 1492 * INSTANCE_FIELD_DECLARATION | |
| 1493 * INSTANCE_FIELD_REFERENCE | |
| 1494 * INSTANCE_GETTER_DECLARATION | |
| 1495 * INSTANCE_GETTER_REFERENCE | |
| 1496 * INSTANCE_METHOD_DECLARATION | |
| 1497 * INSTANCE_METHOD_REFERENCE | |
| 1498 * INSTANCE_SETTER_DECLARATION | |
| 1499 * INSTANCE_SETTER_REFERENCE | |
| 1500 * INVALID_STRING_ESCAPE | |
| 1501 * KEYWORD | |
| 1502 * LABEL | |
| 1503 * LIBRARY_NAME | |
| 1504 * LITERAL_BOOLEAN | |
| 1505 * LITERAL_DOUBLE | |
| 1506 * LITERAL_INTEGER | |
| 1507 * LITERAL_LIST | |
| 1508 * LITERAL_MAP | |
| 1509 * LITERAL_STRING | |
| 1510 * LOCAL_FUNCTION_DECLARATION | |
| 1511 * LOCAL_FUNCTION_REFERENCE | |
| 1512 * LOCAL_VARIABLE | |
| 1513 * LOCAL_VARIABLE_DECLARATION | |
| 1514 * LOCAL_VARIABLE_REFERENCE | |
| 1515 * METHOD | |
| 1516 * METHOD_DECLARATION | |
| 1517 * METHOD_DECLARATION_STATIC | |
| 1518 * METHOD_STATIC | |
| 1519 * PARAMETER | |
| 1520 * SETTER_DECLARATION | |
| 1521 * TOP_LEVEL_VARIABLE | |
| 1522 * PARAMETER_DECLARATION | |
| 1523 * PARAMETER_REFERENCE | |
| 1524 * STATIC_FIELD_DECLARATION | |
| 1525 * STATIC_GETTER_DECLARATION | |
| 1526 * STATIC_GETTER_REFERENCE | |
| 1527 * STATIC_METHOD_DECLARATION | |
| 1528 * STATIC_METHOD_REFERENCE | |
| 1529 * STATIC_SETTER_DECLARATION | |
| 1530 * STATIC_SETTER_REFERENCE | |
| 1531 * TOP_LEVEL_FUNCTION_DECLARATION | |
| 1532 * TOP_LEVEL_FUNCTION_REFERENCE | |
| 1533 * TOP_LEVEL_GETTER_DECLARATION | |
| 1534 * TOP_LEVEL_GETTER_REFERENCE | |
| 1535 * TOP_LEVEL_SETTER_DECLARATION | |
| 1536 * TOP_LEVEL_SETTER_REFERENCE | |
| 1537 * TOP_LEVEL_VARIABLE_DECLARATION | |
| 1538 * TYPE_NAME_DYNAMIC | |
| 1539 * TYPE_PARAMETER | |
| 1540 * UNRESOLVED_INSTANCE_MEMBER_REFERENCE | |
| 1541 * VALID_STRING_ESCAPE | |
| 1542 * } | |
| 1543 */ | |
| 1544 final Matcher isHighlightRegionType = new MatchesEnum("HighlightRegionType", [ | |
| 1545 "ANNOTATION", | |
| 1546 "BUILT_IN", | |
| 1547 "CLASS", | |
| 1548 "COMMENT_BLOCK", | |
| 1549 "COMMENT_DOCUMENTATION", | |
| 1550 "COMMENT_END_OF_LINE", | |
| 1551 "CONSTRUCTOR", | |
| 1552 "DIRECTIVE", | |
| 1553 "DYNAMIC_TYPE", | |
| 1554 "DYNAMIC_LOCAL_VARIABLE_DECLARATION", | |
| 1555 "DYNAMIC_LOCAL_VARIABLE_REFERENCE", | |
| 1556 "DYNAMIC_PARAMETER_DECLARATION", | |
| 1557 "DYNAMIC_PARAMETER_REFERENCE", | |
| 1558 "ENUM", | |
| 1559 "ENUM_CONSTANT", | |
| 1560 "FIELD", | |
| 1561 "FIELD_STATIC", | |
| 1562 "FUNCTION", | |
| 1563 "FUNCTION_DECLARATION", | |
| 1564 "FUNCTION_TYPE_ALIAS", | |
| 1565 "GETTER_DECLARATION", | |
| 1566 "IDENTIFIER_DEFAULT", | |
| 1567 "IMPORT_PREFIX", | |
| 1568 "INSTANCE_FIELD_DECLARATION", | |
| 1569 "INSTANCE_FIELD_REFERENCE", | |
| 1570 "INSTANCE_GETTER_DECLARATION", | |
| 1571 "INSTANCE_GETTER_REFERENCE", | |
| 1572 "INSTANCE_METHOD_DECLARATION", | |
| 1573 "INSTANCE_METHOD_REFERENCE", | |
| 1574 "INSTANCE_SETTER_DECLARATION", | |
| 1575 "INSTANCE_SETTER_REFERENCE", | |
| 1576 "INVALID_STRING_ESCAPE", | |
| 1577 "KEYWORD", | |
| 1578 "LABEL", | |
| 1579 "LIBRARY_NAME", | |
| 1580 "LITERAL_BOOLEAN", | |
| 1581 "LITERAL_DOUBLE", | |
| 1582 "LITERAL_INTEGER", | |
| 1583 "LITERAL_LIST", | |
| 1584 "LITERAL_MAP", | |
| 1585 "LITERAL_STRING", | |
| 1586 "LOCAL_FUNCTION_DECLARATION", | |
| 1587 "LOCAL_FUNCTION_REFERENCE", | |
| 1588 "LOCAL_VARIABLE", | |
| 1589 "LOCAL_VARIABLE_DECLARATION", | |
| 1590 "LOCAL_VARIABLE_REFERENCE", | |
| 1591 "METHOD", | |
| 1592 "METHOD_DECLARATION", | |
| 1593 "METHOD_DECLARATION_STATIC", | |
| 1594 "METHOD_STATIC", | |
| 1595 "PARAMETER", | |
| 1596 "SETTER_DECLARATION", | |
| 1597 "TOP_LEVEL_VARIABLE", | |
| 1598 "PARAMETER_DECLARATION", | |
| 1599 "PARAMETER_REFERENCE", | |
| 1600 "STATIC_FIELD_DECLARATION", | |
| 1601 "STATIC_GETTER_DECLARATION", | |
| 1602 "STATIC_GETTER_REFERENCE", | |
| 1603 "STATIC_METHOD_DECLARATION", | |
| 1604 "STATIC_METHOD_REFERENCE", | |
| 1605 "STATIC_SETTER_DECLARATION", | |
| 1606 "STATIC_SETTER_REFERENCE", | |
| 1607 "TOP_LEVEL_FUNCTION_DECLARATION", | |
| 1608 "TOP_LEVEL_FUNCTION_REFERENCE", | |
| 1609 "TOP_LEVEL_GETTER_DECLARATION", | |
| 1610 "TOP_LEVEL_GETTER_REFERENCE", | |
| 1611 "TOP_LEVEL_SETTER_DECLARATION", | |
| 1612 "TOP_LEVEL_SETTER_REFERENCE", | |
| 1613 "TOP_LEVEL_VARIABLE_DECLARATION", | |
| 1614 "TYPE_NAME_DYNAMIC", | |
| 1615 "TYPE_PARAMETER", | |
| 1616 "UNRESOLVED_INSTANCE_MEMBER_REFERENCE", | |
| 1617 "VALID_STRING_ESCAPE" | |
| 1618 ]); | |
| 1619 | |
| 1620 /** | |
| 1621 * HoverInformation | |
| 1622 * | |
| 1623 * { | |
| 1624 * "offset": int | |
| 1625 * "length": int | |
| 1626 * "containingLibraryPath": optional String | |
| 1627 * "containingLibraryName": optional String | |
| 1628 * "containingClassDescription": optional String | |
| 1629 * "dartdoc": optional String | |
| 1630 * "elementDescription": optional String | |
| 1631 * "elementKind": optional String | |
| 1632 * "isDeprecated": optional bool | |
| 1633 * "parameter": optional String | |
| 1634 * "propagatedType": optional String | |
| 1635 * "staticType": optional String | |
| 1636 * } | |
| 1637 */ | |
| 1638 final Matcher isHoverInformation = | |
| 1639 new LazyMatcher(() => new MatchesJsonObject("HoverInformation", { | |
| 1640 "offset": isInt, | |
| 1641 "length": isInt | |
| 1642 }, optionalFields: { | |
| 1643 "containingLibraryPath": isString, | |
| 1644 "containingLibraryName": isString, | |
| 1645 "containingClassDescription": isString, | |
| 1646 "dartdoc": isString, | |
| 1647 "elementDescription": isString, | |
| 1648 "elementKind": isString, | |
| 1649 "isDeprecated": isBool, | |
| 1650 "parameter": isString, | |
| 1651 "propagatedType": isString, | |
| 1652 "staticType": isString | |
| 1653 })); | |
| 1654 | |
| 1655 /** | |
| 1656 * ImplementedClass | |
| 1657 * | |
| 1658 * { | |
| 1659 * "offset": int | |
| 1660 * "length": int | |
| 1661 * } | |
| 1662 */ | |
| 1663 final Matcher isImplementedClass = new LazyMatcher(() => new MatchesJsonObject( | |
| 1664 "ImplementedClass", {"offset": isInt, "length": isInt})); | |
| 1665 | |
| 1666 /** | |
| 1667 * ImplementedMember | |
| 1668 * | |
| 1669 * { | |
| 1670 * "offset": int | |
| 1671 * "length": int | |
| 1672 * } | |
| 1673 */ | |
| 1674 final Matcher isImplementedMember = new LazyMatcher(() => new MatchesJsonObject( | |
| 1675 "ImplementedMember", {"offset": isInt, "length": isInt})); | |
| 1676 | |
| 1677 /** | |
| 1678 * LinkedEditGroup | |
| 1679 * | |
| 1680 * { | |
| 1681 * "positions": List<Position> | |
| 1682 * "length": int | |
| 1683 * "suggestions": List<LinkedEditSuggestion> | |
| 1684 * } | |
| 1685 */ | |
| 1686 final Matcher isLinkedEditGroup = | |
| 1687 new LazyMatcher(() => new MatchesJsonObject("LinkedEditGroup", { | |
| 1688 "positions": isListOf(isPosition), | |
| 1689 "length": isInt, | |
| 1690 "suggestions": isListOf(isLinkedEditSuggestion) | |
| 1691 })); | |
| 1692 | |
| 1693 /** | |
| 1694 * LinkedEditSuggestion | |
| 1695 * | |
| 1696 * { | |
| 1697 * "value": String | |
| 1698 * "kind": LinkedEditSuggestionKind | |
| 1699 * } | |
| 1700 */ | |
| 1701 final Matcher isLinkedEditSuggestion = new LazyMatcher(() => | |
| 1702 new MatchesJsonObject("LinkedEditSuggestion", | |
| 1703 {"value": isString, "kind": isLinkedEditSuggestionKind})); | |
| 1704 | |
| 1705 /** | |
| 1706 * LinkedEditSuggestionKind | |
| 1707 * | |
| 1708 * enum { | |
| 1709 * METHOD | |
| 1710 * PARAMETER | |
| 1711 * TYPE | |
| 1712 * VARIABLE | |
| 1713 * } | |
| 1714 */ | |
| 1715 final Matcher isLinkedEditSuggestionKind = new MatchesEnum( | |
| 1716 "LinkedEditSuggestionKind", ["METHOD", "PARAMETER", "TYPE", "VARIABLE"]); | |
| 1717 | |
| 1718 /** | |
| 1719 * Location | |
| 1720 * | |
| 1721 * { | |
| 1722 * "file": FilePath | |
| 1723 * "offset": int | |
| 1724 * "length": int | |
| 1725 * "startLine": int | |
| 1726 * "startColumn": int | |
| 1727 * } | |
| 1728 */ | |
| 1729 final Matcher isLocation = | |
| 1730 new LazyMatcher(() => new MatchesJsonObject("Location", { | |
| 1731 "file": isFilePath, | |
| 1732 "offset": isInt, | |
| 1733 "length": isInt, | |
| 1734 "startLine": isInt, | |
| 1735 "startColumn": isInt | |
| 1736 })); | |
| 1737 | |
| 1738 /** | |
| 1739 * NavigationRegion | |
| 1740 * | |
| 1741 * { | |
| 1742 * "offset": int | |
| 1743 * "length": int | |
| 1744 * "targets": List<int> | |
| 1745 * } | |
| 1746 */ | |
| 1747 final Matcher isNavigationRegion = new LazyMatcher(() => new MatchesJsonObject( | |
| 1748 "NavigationRegion", | |
| 1749 {"offset": isInt, "length": isInt, "targets": isListOf(isInt)})); | |
| 1750 | |
| 1751 /** | |
| 1752 * NavigationTarget | |
| 1753 * | |
| 1754 * { | |
| 1755 * "kind": ElementKind | |
| 1756 * "fileIndex": int | |
| 1757 * "offset": int | |
| 1758 * "length": int | |
| 1759 * "startLine": int | |
| 1760 * "startColumn": int | |
| 1761 * } | |
| 1762 */ | |
| 1763 final Matcher isNavigationTarget = | |
| 1764 new LazyMatcher(() => new MatchesJsonObject("NavigationTarget", { | |
| 1765 "kind": isElementKind, | |
| 1766 "fileIndex": isInt, | |
| 1767 "offset": isInt, | |
| 1768 "length": isInt, | |
| 1769 "startLine": isInt, | |
| 1770 "startColumn": isInt | |
| 1771 })); | |
| 1772 | |
| 1773 /** | |
| 1774 * Occurrences | |
| 1775 * | |
| 1776 * { | |
| 1777 * "element": Element | |
| 1778 * "offsets": List<int> | |
| 1779 * "length": int | |
| 1780 * } | |
| 1781 */ | |
| 1782 final Matcher isOccurrences = new LazyMatcher(() => new MatchesJsonObject( | |
| 1783 "Occurrences", | |
| 1784 {"element": isElement, "offsets": isListOf(isInt), "length": isInt})); | |
| 1785 | |
| 1786 /** | |
| 1787 * Outline | |
| 1788 * | |
| 1789 * { | |
| 1790 * "element": Element | |
| 1791 * "offset": int | |
| 1792 * "length": int | |
| 1793 * "children": optional List<Outline> | |
| 1794 * } | |
| 1795 */ | |
| 1796 final Matcher isOutline = new LazyMatcher(() => new MatchesJsonObject( | |
| 1797 "Outline", {"element": isElement, "offset": isInt, "length": isInt}, | |
| 1798 optionalFields: {"children": isListOf(isOutline)})); | |
| 1799 | |
| 1800 /** | |
| 1801 * Override | |
| 1802 * | |
| 1803 * { | |
| 1804 * "offset": int | |
| 1805 * "length": int | |
| 1806 * "superclassMember": optional OverriddenMember | |
| 1807 * "interfaceMembers": optional List<OverriddenMember> | |
| 1808 * } | |
| 1809 */ | |
| 1810 final Matcher isOverride = | |
| 1811 new LazyMatcher(() => new MatchesJsonObject("Override", { | |
| 1812 "offset": isInt, | |
| 1813 "length": isInt | |
| 1814 }, optionalFields: { | |
| 1815 "superclassMember": isOverriddenMember, | |
| 1816 "interfaceMembers": isListOf(isOverriddenMember) | |
| 1817 })); | |
| 1818 | |
| 1819 /** | |
| 1820 * OverriddenMember | |
| 1821 * | |
| 1822 * { | |
| 1823 * "element": Element | |
| 1824 * "className": String | |
| 1825 * } | |
| 1826 */ | |
| 1827 final Matcher isOverriddenMember = new LazyMatcher(() => new MatchesJsonObject( | |
| 1828 "OverriddenMember", {"element": isElement, "className": isString})); | |
| 1829 | |
| 1830 /** | |
| 1831 * Position | |
| 1832 * | |
| 1833 * { | |
| 1834 * "file": FilePath | |
| 1835 * "offset": int | |
| 1836 * } | |
| 1837 */ | |
| 1838 final Matcher isPosition = new LazyMatcher(() => | |
| 1839 new MatchesJsonObject("Position", {"file": isFilePath, "offset": isInt})); | |
| 1840 | |
| 1841 /** | |
| 1842 * PubStatus | |
| 1843 * | |
| 1844 * { | |
| 1845 * "isListingPackageDirs": bool | |
| 1846 * } | |
| 1847 */ | |
| 1848 final Matcher isPubStatus = new LazyMatcher( | |
| 1849 () => new MatchesJsonObject("PubStatus", {"isListingPackageDirs": isBool})); | |
| 1850 | |
| 1851 /** | |
| 1852 * RefactoringKind | |
| 1853 * | |
| 1854 * enum { | |
| 1855 * CONVERT_GETTER_TO_METHOD | |
| 1856 * CONVERT_METHOD_TO_GETTER | |
| 1857 * EXTRACT_LOCAL_VARIABLE | |
| 1858 * EXTRACT_METHOD | |
| 1859 * INLINE_LOCAL_VARIABLE | |
| 1860 * INLINE_METHOD | |
| 1861 * MOVE_FILE | |
| 1862 * RENAME | |
| 1863 * SORT_MEMBERS | |
| 1864 * } | |
| 1865 */ | |
| 1866 final Matcher isRefactoringKind = new MatchesEnum("RefactoringKind", [ | |
| 1867 "CONVERT_GETTER_TO_METHOD", | |
| 1868 "CONVERT_METHOD_TO_GETTER", | |
| 1869 "EXTRACT_LOCAL_VARIABLE", | |
| 1870 "EXTRACT_METHOD", | |
| 1871 "INLINE_LOCAL_VARIABLE", | |
| 1872 "INLINE_METHOD", | |
| 1873 "MOVE_FILE", | |
| 1874 "RENAME", | |
| 1875 "SORT_MEMBERS" | |
| 1876 ]); | |
| 1877 | |
| 1878 /** | |
| 1879 * RefactoringMethodParameter | |
| 1880 * | |
| 1881 * { | |
| 1882 * "id": optional String | |
| 1883 * "kind": RefactoringMethodParameterKind | |
| 1884 * "type": String | |
| 1885 * "name": String | |
| 1886 * "parameters": optional String | |
| 1887 * } | |
| 1888 */ | |
| 1889 final Matcher isRefactoringMethodParameter = new LazyMatcher(() => | |
| 1890 new MatchesJsonObject("RefactoringMethodParameter", { | |
| 1891 "kind": isRefactoringMethodParameterKind, | |
| 1892 "type": isString, | |
| 1893 "name": isString | |
| 1894 }, optionalFields: { | |
| 1895 "id": isString, | |
| 1896 "parameters": isString | |
| 1897 })); | |
| 1898 | |
| 1899 /** | |
| 1900 * RefactoringFeedback | |
| 1901 * | |
| 1902 * { | |
| 1903 * } | |
| 1904 */ | |
| 1905 final Matcher isRefactoringFeedback = | |
| 1906 new LazyMatcher(() => new MatchesJsonObject("RefactoringFeedback", null)); | |
| 1907 | |
| 1908 /** | |
| 1909 * RefactoringOptions | |
| 1910 * | |
| 1911 * { | |
| 1912 * } | |
| 1913 */ | |
| 1914 final Matcher isRefactoringOptions = | |
| 1915 new LazyMatcher(() => new MatchesJsonObject("RefactoringOptions", null)); | |
| 1916 | |
| 1917 /** | |
| 1918 * RefactoringMethodParameterKind | |
| 1919 * | |
| 1920 * enum { | |
| 1921 * REQUIRED | |
| 1922 * POSITIONAL | |
| 1923 * NAMED | |
| 1924 * } | |
| 1925 */ | |
| 1926 final Matcher isRefactoringMethodParameterKind = new MatchesEnum( | |
| 1927 "RefactoringMethodParameterKind", ["REQUIRED", "POSITIONAL", "NAMED"]); | |
| 1928 | |
| 1929 /** | |
| 1930 * RefactoringProblem | |
| 1931 * | |
| 1932 * { | |
| 1933 * "severity": RefactoringProblemSeverity | |
| 1934 * "message": String | |
| 1935 * "location": optional Location | |
| 1936 * } | |
| 1937 */ | |
| 1938 final Matcher isRefactoringProblem = new LazyMatcher(() => | |
| 1939 new MatchesJsonObject("RefactoringProblem", | |
| 1940 {"severity": isRefactoringProblemSeverity, "message": isString}, | |
| 1941 optionalFields: {"location": isLocation})); | |
| 1942 | |
| 1943 /** | |
| 1944 * RefactoringProblemSeverity | |
| 1945 * | |
| 1946 * enum { | |
| 1947 * INFO | |
| 1948 * WARNING | |
| 1949 * ERROR | |
| 1950 * FATAL | |
| 1951 * } | |
| 1952 */ | |
| 1953 final Matcher isRefactoringProblemSeverity = new MatchesEnum( | |
| 1954 "RefactoringProblemSeverity", ["INFO", "WARNING", "ERROR", "FATAL"]); | |
| 1955 | |
| 1956 /** | |
| 1957 * RemoveContentOverlay | |
| 1958 * | |
| 1959 * { | |
| 1960 * "type": "remove" | |
| 1961 * } | |
| 1962 */ | |
| 1963 final Matcher isRemoveContentOverlay = new LazyMatcher(() => | |
| 1964 new MatchesJsonObject("RemoveContentOverlay", {"type": equals("remove")})); | |
| 1965 | |
| 1966 /** | |
| 1967 * RequestError | |
| 1968 * | |
| 1969 * { | |
| 1970 * "code": RequestErrorCode | |
| 1971 * "message": String | |
| 1972 * "stackTrace": optional String | |
| 1973 * } | |
| 1974 */ | |
| 1975 final Matcher isRequestError = new LazyMatcher(() => new MatchesJsonObject( | |
| 1976 "RequestError", {"code": isRequestErrorCode, "message": isString}, | |
| 1977 optionalFields: {"stackTrace": isString})); | |
| 1978 | |
| 1979 /** | |
| 1980 * RequestErrorCode | |
| 1981 * | |
| 1982 * enum { | |
| 1983 * CONTENT_MODIFIED | |
| 1984 * DEBUG_PORT_COULD_NOT_BE_OPENED | |
| 1985 * FILE_NOT_ANALYZED | |
| 1986 * FORMAT_INVALID_FILE | |
| 1987 * FORMAT_WITH_ERRORS | |
| 1988 * GET_ERRORS_INVALID_FILE | |
| 1989 * GET_NAVIGATION_INVALID_FILE | |
| 1990 * GET_REACHABLE_SOURCES_INVALID_FILE | |
| 1991 * INVALID_ANALYSIS_ROOT | |
| 1992 * INVALID_EXECUTION_CONTEXT | |
| 1993 * INVALID_FILE_PATH_FORMAT | |
| 1994 * INVALID_OVERLAY_CHANGE | |
| 1995 * INVALID_PARAMETER | |
| 1996 * INVALID_REQUEST | |
| 1997 * NO_INDEX_GENERATED | |
| 1998 * ORGANIZE_DIRECTIVES_ERROR | |
| 1999 * REFACTORING_REQUEST_CANCELLED | |
| 2000 * SERVER_ALREADY_STARTED | |
| 2001 * SERVER_ERROR | |
| 2002 * SORT_MEMBERS_INVALID_FILE | |
| 2003 * SORT_MEMBERS_PARSE_ERRORS | |
| 2004 * UNANALYZED_PRIORITY_FILES | |
| 2005 * UNKNOWN_REQUEST | |
| 2006 * UNKNOWN_SOURCE | |
| 2007 * UNSUPPORTED_FEATURE | |
| 2008 * } | |
| 2009 */ | |
| 2010 final Matcher isRequestErrorCode = new MatchesEnum("RequestErrorCode", [ | |
| 2011 "CONTENT_MODIFIED", | |
| 2012 "DEBUG_PORT_COULD_NOT_BE_OPENED", | |
| 2013 "FILE_NOT_ANALYZED", | |
| 2014 "FORMAT_INVALID_FILE", | |
| 2015 "FORMAT_WITH_ERRORS", | |
| 2016 "GET_ERRORS_INVALID_FILE", | |
| 2017 "GET_NAVIGATION_INVALID_FILE", | |
| 2018 "GET_REACHABLE_SOURCES_INVALID_FILE", | |
| 2019 "INVALID_ANALYSIS_ROOT", | |
| 2020 "INVALID_EXECUTION_CONTEXT", | |
| 2021 "INVALID_FILE_PATH_FORMAT", | |
| 2022 "INVALID_OVERLAY_CHANGE", | |
| 2023 "INVALID_PARAMETER", | |
| 2024 "INVALID_REQUEST", | |
| 2025 "NO_INDEX_GENERATED", | |
| 2026 "ORGANIZE_DIRECTIVES_ERROR", | |
| 2027 "REFACTORING_REQUEST_CANCELLED", | |
| 2028 "SERVER_ALREADY_STARTED", | |
| 2029 "SERVER_ERROR", | |
| 2030 "SORT_MEMBERS_INVALID_FILE", | |
| 2031 "SORT_MEMBERS_PARSE_ERRORS", | |
| 2032 "UNANALYZED_PRIORITY_FILES", | |
| 2033 "UNKNOWN_REQUEST", | |
| 2034 "UNKNOWN_SOURCE", | |
| 2035 "UNSUPPORTED_FEATURE" | |
| 2036 ]); | |
| 2037 | |
| 2038 /** | |
| 2039 * SearchId | |
| 2040 * | |
| 2041 * String | |
| 2042 */ | |
| 2043 final Matcher isSearchId = isString; | |
| 2044 | |
| 2045 /** | |
| 2046 * SearchResult | |
| 2047 * | |
| 2048 * { | |
| 2049 * "location": Location | |
| 2050 * "kind": SearchResultKind | |
| 2051 * "isPotential": bool | |
| 2052 * "path": List<Element> | |
| 2053 * } | |
| 2054 */ | |
| 2055 final Matcher isSearchResult = | |
| 2056 new LazyMatcher(() => new MatchesJsonObject("SearchResult", { | |
| 2057 "location": isLocation, | |
| 2058 "kind": isSearchResultKind, | |
| 2059 "isPotential": isBool, | |
| 2060 "path": isListOf(isElement) | |
| 2061 })); | |
| 2062 | |
| 2063 /** | |
| 2064 * SearchResultKind | |
| 2065 * | |
| 2066 * enum { | |
| 2067 * DECLARATION | |
| 2068 * INVOCATION | |
| 2069 * READ | |
| 2070 * READ_WRITE | |
| 2071 * REFERENCE | |
| 2072 * UNKNOWN | |
| 2073 * WRITE | |
| 2074 * } | |
| 2075 */ | |
| 2076 final Matcher isSearchResultKind = new MatchesEnum("SearchResultKind", [ | |
| 2077 "DECLARATION", | |
| 2078 "INVOCATION", | |
| 2079 "READ", | |
| 2080 "READ_WRITE", | |
| 2081 "REFERENCE", | |
| 2082 "UNKNOWN", | |
| 2083 "WRITE" | |
| 2084 ]); | |
| 2085 | |
| 2086 /** | |
| 2087 * ServerService | |
| 2088 * | |
| 2089 * enum { | |
| 2090 * STATUS | |
| 2091 * } | |
| 2092 */ | |
| 2093 final Matcher isServerService = new MatchesEnum("ServerService", ["STATUS"]); | |
| 2094 | |
| 2095 /** | |
| 2096 * SourceChange | |
| 2097 * | |
| 2098 * { | |
| 2099 * "message": String | |
| 2100 * "edits": List<SourceFileEdit> | |
| 2101 * "linkedEditGroups": List<LinkedEditGroup> | |
| 2102 * "selection": optional Position | |
| 2103 * } | |
| 2104 */ | |
| 2105 final Matcher isSourceChange = | |
| 2106 new LazyMatcher(() => new MatchesJsonObject("SourceChange", { | |
| 2107 "message": isString, | |
| 2108 "edits": isListOf(isSourceFileEdit), | |
| 2109 "linkedEditGroups": isListOf(isLinkedEditGroup) | |
| 2110 }, optionalFields: { | |
| 2111 "selection": isPosition | |
| 2112 })); | |
| 2113 | |
| 2114 /** | |
| 2115 * SourceEdit | |
| 2116 * | |
| 2117 * { | |
| 2118 * "offset": int | |
| 2119 * "length": int | |
| 2120 * "replacement": String | |
| 2121 * "id": optional String | |
| 2122 * } | |
| 2123 */ | |
| 2124 final Matcher isSourceEdit = new LazyMatcher(() => new MatchesJsonObject( | |
| 2125 "SourceEdit", {"offset": isInt, "length": isInt, "replacement": isString}, | |
| 2126 optionalFields: {"id": isString})); | |
| 2127 | |
| 2128 /** | |
| 2129 * SourceFileEdit | |
| 2130 * | |
| 2131 * { | |
| 2132 * "file": FilePath | |
| 2133 * "fileStamp": long | |
| 2134 * "edits": List<SourceEdit> | |
| 2135 * } | |
| 2136 */ | |
| 2137 final Matcher isSourceFileEdit = new LazyMatcher(() => new MatchesJsonObject( | |
| 2138 "SourceFileEdit", | |
| 2139 {"file": isFilePath, "fileStamp": isInt, "edits": isListOf(isSourceEdit)})); | |
| 2140 | |
| 2141 /** | |
| 2142 * TypeHierarchyItem | |
| 2143 * | |
| 2144 * { | |
| 2145 * "classElement": Element | |
| 2146 * "displayName": optional String | |
| 2147 * "memberElement": optional Element | |
| 2148 * "superclass": optional int | |
| 2149 * "interfaces": List<int> | |
| 2150 * "mixins": List<int> | |
| 2151 * "subclasses": List<int> | |
| 2152 * } | |
| 2153 */ | |
| 2154 final Matcher isTypeHierarchyItem = | |
| 2155 new LazyMatcher(() => new MatchesJsonObject("TypeHierarchyItem", { | |
| 2156 "classElement": isElement, | |
| 2157 "interfaces": isListOf(isInt), | |
| 2158 "mixins": isListOf(isInt), | |
| 2159 "subclasses": isListOf(isInt) | |
| 2160 }, optionalFields: { | |
| 2161 "displayName": isString, | |
| 2162 "memberElement": isElement, | |
| 2163 "superclass": isInt | |
| 2164 })); | |
| 2165 | |
| 2166 /** | |
| 2167 * convertGetterToMethod feedback | |
| 2168 */ | |
| 2169 final Matcher isConvertGetterToMethodFeedback = isNull; | |
| 2170 | |
| 2171 /** | |
| 2172 * convertGetterToMethod options | |
| 2173 */ | |
| 2174 final Matcher isConvertGetterToMethodOptions = isNull; | |
| 2175 | |
| 2176 /** | |
| 2177 * convertMethodToGetter feedback | |
| 2178 */ | |
| 2179 final Matcher isConvertMethodToGetterFeedback = isNull; | |
| 2180 | |
| 2181 /** | |
| 2182 * convertMethodToGetter options | |
| 2183 */ | |
| 2184 final Matcher isConvertMethodToGetterOptions = isNull; | |
| 2185 | |
| 2186 /** | |
| 2187 * extractLocalVariable feedback | |
| 2188 * | |
| 2189 * { | |
| 2190 * "coveringExpressionOffsets": optional List<int> | |
| 2191 * "coveringExpressionLengths": optional List<int> | |
| 2192 * "names": List<String> | |
| 2193 * "offsets": List<int> | |
| 2194 * "lengths": List<int> | |
| 2195 * } | |
| 2196 */ | |
| 2197 final Matcher isExtractLocalVariableFeedback = new LazyMatcher( | |
| 2198 () => new MatchesJsonObject("extractLocalVariable feedback", { | |
| 2199 "names": isListOf(isString), | |
| 2200 "offsets": isListOf(isInt), | |
| 2201 "lengths": isListOf(isInt) | |
| 2202 }, optionalFields: { | |
| 2203 "coveringExpressionOffsets": isListOf(isInt), | |
| 2204 "coveringExpressionLengths": isListOf(isInt) | |
| 2205 })); | |
| 2206 | |
| 2207 /** | |
| 2208 * extractLocalVariable options | |
| 2209 * | |
| 2210 * { | |
| 2211 * "name": String | |
| 2212 * "extractAll": bool | |
| 2213 * } | |
| 2214 */ | |
| 2215 final Matcher isExtractLocalVariableOptions = new LazyMatcher(() => | |
| 2216 new MatchesJsonObject("extractLocalVariable options", | |
| 2217 {"name": isString, "extractAll": isBool})); | |
| 2218 | |
| 2219 /** | |
| 2220 * extractMethod feedback | |
| 2221 * | |
| 2222 * { | |
| 2223 * "offset": int | |
| 2224 * "length": int | |
| 2225 * "returnType": String | |
| 2226 * "names": List<String> | |
| 2227 * "canCreateGetter": bool | |
| 2228 * "parameters": List<RefactoringMethodParameter> | |
| 2229 * "offsets": List<int> | |
| 2230 * "lengths": List<int> | |
| 2231 * } | |
| 2232 */ | |
| 2233 final Matcher isExtractMethodFeedback = | |
| 2234 new LazyMatcher(() => new MatchesJsonObject("extractMethod feedback", { | |
| 2235 "offset": isInt, | |
| 2236 "length": isInt, | |
| 2237 "returnType": isString, | |
| 2238 "names": isListOf(isString), | |
| 2239 "canCreateGetter": isBool, | |
| 2240 "parameters": isListOf(isRefactoringMethodParameter), | |
| 2241 "offsets": isListOf(isInt), | |
| 2242 "lengths": isListOf(isInt) | |
| 2243 })); | |
| 2244 | |
| 2245 /** | |
| 2246 * extractMethod options | |
| 2247 * | |
| 2248 * { | |
| 2249 * "returnType": String | |
| 2250 * "createGetter": bool | |
| 2251 * "name": String | |
| 2252 * "parameters": List<RefactoringMethodParameter> | |
| 2253 * "extractAll": bool | |
| 2254 * } | |
| 2255 */ | |
| 2256 final Matcher isExtractMethodOptions = | |
| 2257 new LazyMatcher(() => new MatchesJsonObject("extractMethod options", { | |
| 2258 "returnType": isString, | |
| 2259 "createGetter": isBool, | |
| 2260 "name": isString, | |
| 2261 "parameters": isListOf(isRefactoringMethodParameter), | |
| 2262 "extractAll": isBool | |
| 2263 })); | |
| 2264 | |
| 2265 /** | |
| 2266 * inlineLocalVariable feedback | |
| 2267 * | |
| 2268 * { | |
| 2269 * "name": String | |
| 2270 * "occurrences": int | |
| 2271 * } | |
| 2272 */ | |
| 2273 final Matcher isInlineLocalVariableFeedback = new LazyMatcher(() => | |
| 2274 new MatchesJsonObject("inlineLocalVariable feedback", | |
| 2275 {"name": isString, "occurrences": isInt})); | |
| 2276 | |
| 2277 /** | |
| 2278 * inlineLocalVariable options | |
| 2279 */ | |
| 2280 final Matcher isInlineLocalVariableOptions = isNull; | |
| 2281 | |
| 2282 /** | |
| 2283 * inlineMethod feedback | |
| 2284 * | |
| 2285 * { | |
| 2286 * "className": optional String | |
| 2287 * "methodName": String | |
| 2288 * "isDeclaration": bool | |
| 2289 * } | |
| 2290 */ | |
| 2291 final Matcher isInlineMethodFeedback = new LazyMatcher(() => | |
| 2292 new MatchesJsonObject("inlineMethod feedback", | |
| 2293 {"methodName": isString, "isDeclaration": isBool}, | |
| 2294 optionalFields: {"className": isString})); | |
| 2295 | |
| 2296 /** | |
| 2297 * inlineMethod options | |
| 2298 * | |
| 2299 * { | |
| 2300 * "deleteSource": bool | |
| 2301 * "inlineAll": bool | |
| 2302 * } | |
| 2303 */ | |
| 2304 final Matcher isInlineMethodOptions = new LazyMatcher(() => | |
| 2305 new MatchesJsonObject( | |
| 2306 "inlineMethod options", {"deleteSource": isBool, "inlineAll": isBool})); | |
| 2307 | |
| 2308 /** | |
| 2309 * moveFile feedback | |
| 2310 */ | |
| 2311 final Matcher isMoveFileFeedback = isNull; | |
| 2312 | |
| 2313 /** | |
| 2314 * moveFile options | |
| 2315 * | |
| 2316 * { | |
| 2317 * "newFile": FilePath | |
| 2318 * } | |
| 2319 */ | |
| 2320 final Matcher isMoveFileOptions = new LazyMatcher( | |
| 2321 () => new MatchesJsonObject("moveFile options", {"newFile": isFilePath})); | |
| 2322 | |
| 2323 /** | |
| 2324 * rename feedback | |
| 2325 * | |
| 2326 * { | |
| 2327 * "offset": int | |
| 2328 * "length": int | |
| 2329 * "elementKindName": String | |
| 2330 * "oldName": String | |
| 2331 * } | |
| 2332 */ | |
| 2333 final Matcher isRenameFeedback = | |
| 2334 new LazyMatcher(() => new MatchesJsonObject("rename feedback", { | |
| 2335 "offset": isInt, | |
| 2336 "length": isInt, | |
| 2337 "elementKindName": isString, | |
| 2338 "oldName": isString | |
| 2339 })); | |
| 2340 | |
| 2341 /** | |
| 2342 * rename options | |
| 2343 * | |
| 2344 * { | |
| 2345 * "newName": String | |
| 2346 * } | |
| 2347 */ | |
| 2348 final Matcher isRenameOptions = new LazyMatcher( | |
| 2349 () => new MatchesJsonObject("rename options", {"newName": isString})); | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2844273003:
Unify the server and plugin versions of the generators (Closed)
