| 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 library test.services.completion.dart.local; | |
| 6 | |
| 7 import 'package:analysis_server/src/protocol_server.dart'; | |
| 8 import 'package:analysis_server/src/services/completion/dart_completion_manager.
dart'; | |
| 9 import 'package:analysis_server/src/services/completion/local_computer.dart'; | |
| 10 import 'package:unittest/unittest.dart'; | |
| 11 | |
| 12 import '../../reflective_tests.dart'; | |
| 13 import 'completion_test_util.dart'; | |
| 14 | |
| 15 main() { | |
| 16 groupSep = ' | '; | |
| 17 runReflectiveTests(LocalReferenceContributorTest); | |
| 18 } | |
| 19 | |
| 20 @reflectiveTest | |
| 21 class LocalReferenceContributorTest extends AbstractSelectorSuggestionTest { | |
| 22 @override | |
| 23 CompletionSuggestion assertSuggestLocalClass(String name, | |
| 24 {CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION, | |
| 25 int relevance: DART_RELEVANCE_DEFAULT, bool isDeprecated: false}) { | |
| 26 return assertSuggestClass(name, | |
| 27 kind: kind, relevance: relevance, isDeprecated: isDeprecated); | |
| 28 } | |
| 29 | |
| 30 @override | |
| 31 CompletionSuggestion assertSuggestLocalClassTypeAlias(String name, | |
| 32 {int relevance: DART_RELEVANCE_DEFAULT}) { | |
| 33 return assertSuggestClassTypeAlias(name, relevance); | |
| 34 } | |
| 35 | |
| 36 @override | |
| 37 CompletionSuggestion assertSuggestLocalConstructor(String name) { | |
| 38 return assertSuggestConstructor(name); | |
| 39 } | |
| 40 | |
| 41 @override | |
| 42 CompletionSuggestion assertSuggestLocalField(String name, String type, | |
| 43 {int relevance: DART_RELEVANCE_LOCAL_FIELD, bool deprecated: false}) { | |
| 44 return assertSuggestField(name, type, | |
| 45 relevance: relevance, isDeprecated: deprecated); | |
| 46 } | |
| 47 | |
| 48 @override | |
| 49 CompletionSuggestion assertSuggestLocalFunction( | |
| 50 String name, String returnType, | |
| 51 {CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION, | |
| 52 bool deprecated: false, int relevance: DART_RELEVANCE_LOCAL_FUNCTION}) { | |
| 53 return assertSuggestFunction(name, returnType, | |
| 54 kind: kind, deprecated: deprecated, relevance: relevance); | |
| 55 } | |
| 56 | |
| 57 @override | |
| 58 CompletionSuggestion assertSuggestLocalFunctionTypeAlias( | |
| 59 String name, String returnType, | |
| 60 {bool deprecated: false, int relevance: DART_RELEVANCE_DEFAULT}) { | |
| 61 return assertSuggestFunctionTypeAlias( | |
| 62 name, returnType, deprecated, relevance); | |
| 63 } | |
| 64 | |
| 65 @override | |
| 66 CompletionSuggestion assertSuggestLocalGetter(String name, String returnType, | |
| 67 {int relevance: DART_RELEVANCE_LOCAL_ACCESSOR, bool deprecated: false}) { | |
| 68 return assertSuggestGetter(name, returnType, | |
| 69 relevance: relevance, isDeprecated: deprecated); | |
| 70 } | |
| 71 | |
| 72 @override | |
| 73 CompletionSuggestion assertSuggestLocalMethod( | |
| 74 String name, String declaringType, String returnType, | |
| 75 {int relevance: DART_RELEVANCE_LOCAL_METHOD, bool deprecated: false}) { | |
| 76 return assertSuggestMethod(name, declaringType, returnType, | |
| 77 relevance: relevance, isDeprecated: deprecated); | |
| 78 } | |
| 79 | |
| 80 @override | |
| 81 CompletionSuggestion assertSuggestLocalSetter(String name, | |
| 82 {int relevance: DART_RELEVANCE_LOCAL_ACCESSOR}) { | |
| 83 return assertSuggestSetter(name, relevance); | |
| 84 } | |
| 85 | |
| 86 @override | |
| 87 CompletionSuggestion assertSuggestLocalTopLevelVar( | |
| 88 String name, String returnType, | |
| 89 {int relevance: DART_RELEVANCE_LOCAL_TOP_LEVEL_VARIABLE}) { | |
| 90 return assertSuggestTopLevelVar(name, returnType, relevance); | |
| 91 } | |
| 92 | |
| 93 @override | |
| 94 CompletionSuggestion assertSuggestLocalVariable( | |
| 95 String name, String returnType, | |
| 96 {int relevance: DART_RELEVANCE_LOCAL_VARIABLE}) { | |
| 97 // Local variables should only be suggested by LocalReferenceContributor | |
| 98 CompletionSuggestion cs = assertSuggest(name, | |
| 99 csKind: CompletionSuggestionKind.INVOCATION, relevance: relevance); | |
| 100 expect(cs.returnType, returnType != null ? returnType : 'dynamic'); | |
| 101 Element element = cs.element; | |
| 102 expect(element, isNotNull); | |
| 103 expect(element.kind, equals(ElementKind.LOCAL_VARIABLE)); | |
| 104 expect(element.name, equals(name)); | |
| 105 expect(element.parameters, isNull); | |
| 106 expect(element.returnType, returnType != null ? returnType : 'dynamic'); | |
| 107 assertHasNoParameterInfo(cs); | |
| 108 return cs; | |
| 109 } | |
| 110 | |
| 111 CompletionSuggestion assertSuggestParameter(String name, String returnType, | |
| 112 {int relevance: DART_RELEVANCE_PARAMETER}) { | |
| 113 CompletionSuggestion cs = assertSuggest(name, | |
| 114 csKind: CompletionSuggestionKind.INVOCATION, relevance: relevance); | |
| 115 expect(cs.returnType, returnType != null ? returnType : 'dynamic'); | |
| 116 Element element = cs.element; | |
| 117 expect(element, isNotNull); | |
| 118 expect(element.kind, equals(ElementKind.PARAMETER)); | |
| 119 expect(element.name, equals(name)); | |
| 120 expect(element.parameters, isNull); | |
| 121 expect(element.returnType, | |
| 122 equals(returnType != null ? returnType : 'dynamic')); | |
| 123 return cs; | |
| 124 } | |
| 125 | |
| 126 fail_mixin_ordering() { | |
| 127 // TODO(paulberry): Duplicates aren't being removed, so we see both M1.m() | |
| 128 // and M2.m(). | |
| 129 addTestSource(''' | |
| 130 class B {} | |
| 131 class M1 { | |
| 132 void m() {} | |
| 133 } | |
| 134 class M2 { | |
| 135 void m() {} | |
| 136 } | |
| 137 class C extends B with M1, M2 { | |
| 138 void f() { | |
| 139 ^ | |
| 140 } | |
| 141 } | |
| 142 '''); | |
| 143 expect(computeFast(), isTrue); | |
| 144 assertSuggestMethod('m', 'M2', 'void'); | |
| 145 } | |
| 146 | |
| 147 @override | |
| 148 void setUpContributor() { | |
| 149 contributor = new LocalReferenceContributor(); | |
| 150 } | |
| 151 | |
| 152 test_missing_params_function() { | |
| 153 addTestSource('int f1{} main(){f^}'); | |
| 154 expect(computeFast(), isTrue); | |
| 155 } | |
| 156 | |
| 157 test_missing_params_method() { | |
| 158 addTestSource('class C1{int f1{} main(){f^}}'); | |
| 159 expect(computeFast(), isTrue); | |
| 160 } | |
| 161 | |
| 162 test_missing_params_constructor() { | |
| 163 addTestSource('class C1{C1{} main(){C^}}'); | |
| 164 expect(computeFast(), isTrue); | |
| 165 } | |
| 166 | |
| 167 test_break_ignores_outer_functions_using_closure() { | |
| 168 addTestSource(''' | |
| 169 void main() { | |
| 170 foo: while (true) { | |
| 171 var f = () { | |
| 172 bar: while (true) { break ^ } | |
| 173 }; | |
| 174 } | |
| 175 } | |
| 176 '''); | |
| 177 expect(computeFast(), isTrue); | |
| 178 // Labels in outer functions are never accessible. | |
| 179 assertSuggestLabel('bar'); | |
| 180 assertNotSuggested('foo'); | |
| 181 } | |
| 182 | |
| 183 test_break_ignores_outer_functions_using_local_function() { | |
| 184 addTestSource(''' | |
| 185 void main() { | |
| 186 foo: while (true) { | |
| 187 void f() { | |
| 188 bar: while (true) { break ^ } | |
| 189 }; | |
| 190 } | |
| 191 } | |
| 192 '''); | |
| 193 expect(computeFast(), isTrue); | |
| 194 // Labels in outer functions are never accessible. | |
| 195 assertSuggestLabel('bar'); | |
| 196 assertNotSuggested('foo'); | |
| 197 } | |
| 198 | |
| 199 test_break_ignores_toplevel_variables() { | |
| 200 addTestSource(''' | |
| 201 int x; | |
| 202 void main() { | |
| 203 while (true) { | |
| 204 break ^ | |
| 205 } | |
| 206 } | |
| 207 '''); | |
| 208 expect(computeFast(), isTrue); | |
| 209 assertNotSuggested('x'); | |
| 210 } | |
| 211 | |
| 212 test_break_ignores_unrelated_statements() { | |
| 213 addTestSource(''' | |
| 214 void main() { | |
| 215 foo: while (true) {} | |
| 216 while (true) { break ^ } | |
| 217 bar: while (true) {} | |
| 218 } | |
| 219 '''); | |
| 220 expect(computeFast(), isTrue); | |
| 221 // The scope of the label defined by a labeled statement is just the | |
| 222 // statement itself, so neither "foo" nor "bar" are in scope at the caret | |
| 223 // position. | |
| 224 assertNotSuggested('foo'); | |
| 225 assertNotSuggested('bar'); | |
| 226 } | |
| 227 | |
| 228 test_break_to_enclosing_loop() { | |
| 229 addTestSource(''' | |
| 230 void main() { | |
| 231 foo: while (true) { | |
| 232 bar: while (true) { | |
| 233 break ^ | |
| 234 } | |
| 235 } | |
| 236 } | |
| 237 '''); | |
| 238 expect(computeFast(), isTrue); | |
| 239 assertSuggestLabel('foo'); | |
| 240 assertSuggestLabel('bar'); | |
| 241 } | |
| 242 | |
| 243 test_constructor_parameters_mixed_required_and_named() { | |
| 244 addTestSource('class A {A(x, {int y}) {^}}'); | |
| 245 expect(computeFast(), isTrue); | |
| 246 assertSuggestParameter('x', null); | |
| 247 assertSuggestParameter('y', 'int'); | |
| 248 } | |
| 249 | |
| 250 test_constructor_parameters_mixed_required_and_positional() { | |
| 251 addTestSource('class A {A(x, [int y]) {^}}'); | |
| 252 expect(computeFast(), isTrue); | |
| 253 assertSuggestParameter('x', null); | |
| 254 assertSuggestParameter('y', 'int'); | |
| 255 } | |
| 256 | |
| 257 test_constructor_parameters_named() { | |
| 258 addTestSource('class A {A({x, int y}) {^}}'); | |
| 259 expect(computeFast(), isTrue); | |
| 260 assertSuggestParameter('x', null); | |
| 261 assertSuggestParameter('y', 'int'); | |
| 262 } | |
| 263 | |
| 264 test_constructor_parameters_positional() { | |
| 265 addTestSource('class A {A([x, int y]) {^}}'); | |
| 266 expect(computeFast(), isTrue); | |
| 267 assertSuggestParameter('x', null); | |
| 268 assertSuggestParameter('y', 'int'); | |
| 269 } | |
| 270 | |
| 271 test_constructor_parameters_required() { | |
| 272 addTestSource('class A {A(x, int y) {^}}'); | |
| 273 expect(computeFast(), isTrue); | |
| 274 assertSuggestParameter('x', null); | |
| 275 assertSuggestParameter('y', 'int'); | |
| 276 } | |
| 277 | |
| 278 test_continue_from_loop_to_switch() { | |
| 279 addTestSource(''' | |
| 280 void main() { | |
| 281 switch (x) { | |
| 282 foo: case 1: | |
| 283 break; | |
| 284 bar: case 2: | |
| 285 while (true) { | |
| 286 continue ^; | |
| 287 } | |
| 288 break; | |
| 289 baz: case 3: | |
| 290 break; | |
| 291 } | |
| 292 } | |
| 293 '''); | |
| 294 expect(computeFast(), isTrue); | |
| 295 assertSuggestLabel('foo'); | |
| 296 assertSuggestLabel('bar'); | |
| 297 assertSuggestLabel('baz'); | |
| 298 } | |
| 299 | |
| 300 test_continue_from_switch_to_loop() { | |
| 301 addTestSource(''' | |
| 302 void main() { | |
| 303 foo: while (true) { | |
| 304 switch (x) { | |
| 305 case 1: | |
| 306 continue ^; | |
| 307 } | |
| 308 } | |
| 309 } | |
| 310 '''); | |
| 311 expect(computeFast(), isTrue); | |
| 312 assertSuggestLabel('foo'); | |
| 313 } | |
| 314 | |
| 315 test_continue_ignores_outer_functions_using_closure_with_loop() { | |
| 316 addTestSource(''' | |
| 317 void main() { | |
| 318 foo: while (true) { | |
| 319 var f = () { | |
| 320 bar: while (true) { continue ^ } | |
| 321 }; | |
| 322 } | |
| 323 } | |
| 324 '''); | |
| 325 expect(computeFast(), isTrue); | |
| 326 // Labels in outer functions are never accessible. | |
| 327 assertSuggestLabel('bar'); | |
| 328 assertNotSuggested('foo'); | |
| 329 } | |
| 330 | |
| 331 test_continue_ignores_outer_functions_using_closure_with_switch() { | |
| 332 addTestSource(''' | |
| 333 void main() { | |
| 334 switch (x) { | |
| 335 foo: case 1: | |
| 336 var f = () { | |
| 337 bar: while (true) { continue ^ } | |
| 338 }; | |
| 339 } | |
| 340 } | |
| 341 '''); | |
| 342 expect(computeFast(), isTrue); | |
| 343 // Labels in outer functions are never accessible. | |
| 344 assertSuggestLabel('bar'); | |
| 345 assertNotSuggested('foo'); | |
| 346 } | |
| 347 | |
| 348 test_continue_ignores_outer_functions_using_local_function_with_loop() { | |
| 349 addTestSource(''' | |
| 350 void main() { | |
| 351 foo: while (true) { | |
| 352 void f() { | |
| 353 bar: while (true) { continue ^ } | |
| 354 }; | |
| 355 } | |
| 356 } | |
| 357 '''); | |
| 358 expect(computeFast(), isTrue); | |
| 359 // Labels in outer functions are never accessible. | |
| 360 assertSuggestLabel('bar'); | |
| 361 assertNotSuggested('foo'); | |
| 362 } | |
| 363 | |
| 364 test_continue_ignores_outer_functions_using_local_function_with_switch() { | |
| 365 addTestSource(''' | |
| 366 void main() { | |
| 367 switch (x) { | |
| 368 foo: case 1: | |
| 369 void f() { | |
| 370 bar: while (true) { continue ^ } | |
| 371 }; | |
| 372 } | |
| 373 } | |
| 374 '''); | |
| 375 expect(computeFast(), isTrue); | |
| 376 // Labels in outer functions are never accessible. | |
| 377 assertSuggestLabel('bar'); | |
| 378 assertNotSuggested('foo'); | |
| 379 } | |
| 380 | |
| 381 test_continue_ignores_unrelated_statements() { | |
| 382 addTestSource(''' | |
| 383 void main() { | |
| 384 foo: while (true) {} | |
| 385 while (true) { continue ^ } | |
| 386 bar: while (true) {} | |
| 387 } | |
| 388 '''); | |
| 389 expect(computeFast(), isTrue); | |
| 390 // The scope of the label defined by a labeled statement is just the | |
| 391 // statement itself, so neither "foo" nor "bar" are in scope at the caret | |
| 392 // position. | |
| 393 assertNotSuggested('foo'); | |
| 394 assertNotSuggested('bar'); | |
| 395 } | |
| 396 | |
| 397 test_continue_to_earlier_case() { | |
| 398 addTestSource(''' | |
| 399 void main() { | |
| 400 switch (x) { | |
| 401 foo: case 1: | |
| 402 break; | |
| 403 case 2: | |
| 404 continue ^; | |
| 405 case 3: | |
| 406 break; | |
| 407 '''); | |
| 408 expect(computeFast(), isTrue); | |
| 409 assertSuggestLabel('foo'); | |
| 410 } | |
| 411 | |
| 412 test_continue_to_enclosing_loop() { | |
| 413 addTestSource(''' | |
| 414 void main() { | |
| 415 foo: while (true) { | |
| 416 bar: while (true) { | |
| 417 continue ^ | |
| 418 } | |
| 419 } | |
| 420 } | |
| 421 '''); | |
| 422 expect(computeFast(), isTrue); | |
| 423 assertSuggestLabel('foo'); | |
| 424 assertSuggestLabel('bar'); | |
| 425 } | |
| 426 | |
| 427 test_continue_to_enclosing_switch() { | |
| 428 addTestSource(''' | |
| 429 void main() { | |
| 430 switch (x) { | |
| 431 foo: case 1: | |
| 432 break; | |
| 433 bar: case 2: | |
| 434 switch (y) { | |
| 435 case 1: | |
| 436 continue ^; | |
| 437 } | |
| 438 break; | |
| 439 baz: case 3: | |
| 440 break; | |
| 441 } | |
| 442 } | |
| 443 '''); | |
| 444 expect(computeFast(), isTrue); | |
| 445 assertSuggestLabel('foo'); | |
| 446 assertSuggestLabel('bar'); | |
| 447 assertSuggestLabel('baz'); | |
| 448 } | |
| 449 | |
| 450 test_continue_to_later_case() { | |
| 451 addTestSource(''' | |
| 452 void main() { | |
| 453 switch (x) { | |
| 454 case 1: | |
| 455 break; | |
| 456 case 2: | |
| 457 continue ^; | |
| 458 foo: case 3: | |
| 459 break; | |
| 460 '''); | |
| 461 expect(computeFast(), isTrue); | |
| 462 assertSuggestLabel('foo'); | |
| 463 } | |
| 464 | |
| 465 test_continue_to_same_case() { | |
| 466 addTestSource(''' | |
| 467 void main() { | |
| 468 switch (x) { | |
| 469 case 1: | |
| 470 break; | |
| 471 foo: case 2: | |
| 472 continue ^; | |
| 473 case 3: | |
| 474 break; | |
| 475 '''); | |
| 476 expect(computeFast(), isTrue); | |
| 477 assertSuggestLabel('foo'); | |
| 478 } | |
| 479 | |
| 480 test_function_parameters_mixed_required_and_named() { | |
| 481 addTestSource(''' | |
| 482 void m(x, {int y}) {} | |
| 483 class B extends A { | |
| 484 main() {^} | |
| 485 } | |
| 486 '''); | |
| 487 expect(computeFast(), isTrue); | |
| 488 CompletionSuggestion suggestion = assertSuggestLocalFunction('m', 'void'); | |
| 489 expect(suggestion.parameterNames, hasLength(2)); | |
| 490 expect(suggestion.parameterNames[0], 'x'); | |
| 491 expect(suggestion.parameterTypes[0], 'dynamic'); | |
| 492 expect(suggestion.parameterNames[1], 'y'); | |
| 493 expect(suggestion.parameterTypes[1], 'int'); | |
| 494 expect(suggestion.requiredParameterCount, 1); | |
| 495 expect(suggestion.hasNamedParameters, true); | |
| 496 } | |
| 497 | |
| 498 test_function_parameters_mixed_required_and_positional() { | |
| 499 addTestSource(''' | |
| 500 void m(x, [int y]) {} | |
| 501 class B extends A { | |
| 502 main() {^} | |
| 503 } | |
| 504 '''); | |
| 505 expect(computeFast(), isTrue); | |
| 506 CompletionSuggestion suggestion = assertSuggestLocalFunction('m', 'void'); | |
| 507 expect(suggestion.parameterNames, hasLength(2)); | |
| 508 expect(suggestion.parameterNames[0], 'x'); | |
| 509 expect(suggestion.parameterTypes[0], 'dynamic'); | |
| 510 expect(suggestion.parameterNames[1], 'y'); | |
| 511 expect(suggestion.parameterTypes[1], 'int'); | |
| 512 expect(suggestion.requiredParameterCount, 1); | |
| 513 expect(suggestion.hasNamedParameters, false); | |
| 514 } | |
| 515 | |
| 516 test_function_parameters_named() { | |
| 517 addTestSource(''' | |
| 518 void m({x, int y}) {} | |
| 519 class B extends A { | |
| 520 main() {^} | |
| 521 } | |
| 522 '''); | |
| 523 expect(computeFast(), isTrue); | |
| 524 CompletionSuggestion suggestion = assertSuggestLocalFunction('m', 'void'); | |
| 525 expect(suggestion.parameterNames, hasLength(2)); | |
| 526 expect(suggestion.parameterNames[0], 'x'); | |
| 527 expect(suggestion.parameterTypes[0], 'dynamic'); | |
| 528 expect(suggestion.parameterNames[1], 'y'); | |
| 529 expect(suggestion.parameterTypes[1], 'int'); | |
| 530 expect(suggestion.requiredParameterCount, 0); | |
| 531 expect(suggestion.hasNamedParameters, true); | |
| 532 } | |
| 533 | |
| 534 test_function_parameters_none() { | |
| 535 addTestSource(''' | |
| 536 void m() {} | |
| 537 class B extends A { | |
| 538 main() {^} | |
| 539 } | |
| 540 '''); | |
| 541 expect(computeFast(), isTrue); | |
| 542 CompletionSuggestion suggestion = assertSuggestLocalFunction('m', 'void'); | |
| 543 expect(suggestion.parameterNames, isEmpty); | |
| 544 expect(suggestion.parameterTypes, isEmpty); | |
| 545 expect(suggestion.requiredParameterCount, 0); | |
| 546 expect(suggestion.hasNamedParameters, false); | |
| 547 } | |
| 548 | |
| 549 test_function_parameters_positional() { | |
| 550 addTestSource(''' | |
| 551 void m([x, int y]) {} | |
| 552 class B extends A { | |
| 553 main() {^} | |
| 554 } | |
| 555 '''); | |
| 556 expect(computeFast(), isTrue); | |
| 557 CompletionSuggestion suggestion = assertSuggestLocalFunction('m', 'void'); | |
| 558 expect(suggestion.parameterNames, hasLength(2)); | |
| 559 expect(suggestion.parameterNames[0], 'x'); | |
| 560 expect(suggestion.parameterTypes[0], 'dynamic'); | |
| 561 expect(suggestion.parameterNames[1], 'y'); | |
| 562 expect(suggestion.parameterTypes[1], 'int'); | |
| 563 expect(suggestion.requiredParameterCount, 0); | |
| 564 expect(suggestion.hasNamedParameters, false); | |
| 565 } | |
| 566 | |
| 567 test_function_parameters_required() { | |
| 568 addTestSource(''' | |
| 569 void m(x, int y) {} | |
| 570 class B extends A { | |
| 571 main() {^} | |
| 572 } | |
| 573 '''); | |
| 574 expect(computeFast(), isTrue); | |
| 575 CompletionSuggestion suggestion = assertSuggestLocalFunction('m', 'void'); | |
| 576 expect(suggestion.parameterNames, hasLength(2)); | |
| 577 expect(suggestion.parameterNames[0], 'x'); | |
| 578 expect(suggestion.parameterTypes[0], 'dynamic'); | |
| 579 expect(suggestion.parameterNames[1], 'y'); | |
| 580 expect(suggestion.parameterTypes[1], 'int'); | |
| 581 expect(suggestion.requiredParameterCount, 2); | |
| 582 expect(suggestion.hasNamedParameters, false); | |
| 583 } | |
| 584 | |
| 585 test_ignore_symbol_being_completed() { | |
| 586 addTestSource('class MyClass { } main(MC^) { }'); | |
| 587 expect(computeFast(), isTrue); | |
| 588 assertSuggestLocalClass('MyClass'); | |
| 589 assertNotSuggested('MC'); | |
| 590 } | |
| 591 | |
| 592 test_InstanceCreationExpression() { | |
| 593 addTestSource(''' | |
| 594 class A {foo(){var f; {var x;}}} | |
| 595 class B {B(this.x, [String boo]) { } int x;} | |
| 596 class C {C.bar({boo: 'hoo', int z: 0}) { } } | |
| 597 main() {new ^ String x = "hello";}'''); | |
| 598 computeFast(); | |
| 599 return computeFull((bool result) { | |
| 600 CompletionSuggestion suggestion; | |
| 601 | |
| 602 suggestion = assertSuggestLocalConstructor('A'); | |
| 603 expect(suggestion.element.parameters, '()'); | |
| 604 expect(suggestion.element.returnType, 'A'); | |
| 605 expect(suggestion.declaringType, 'A'); | |
| 606 expect(suggestion.parameterNames, hasLength(0)); | |
| 607 expect(suggestion.requiredParameterCount, 0); | |
| 608 expect(suggestion.hasNamedParameters, false); | |
| 609 | |
| 610 suggestion = assertSuggestLocalConstructor('B'); | |
| 611 expect(suggestion.element.parameters, '(int x, [String boo])'); | |
| 612 expect(suggestion.element.returnType, 'B'); | |
| 613 expect(suggestion.declaringType, 'B'); | |
| 614 expect(suggestion.parameterNames, hasLength(2)); | |
| 615 expect(suggestion.parameterNames[0], 'x'); | |
| 616 expect(suggestion.parameterTypes[0], 'int'); | |
| 617 expect(suggestion.parameterNames[1], 'boo'); | |
| 618 expect(suggestion.parameterTypes[1], 'String'); | |
| 619 expect(suggestion.requiredParameterCount, 1); | |
| 620 expect(suggestion.hasNamedParameters, false); | |
| 621 | |
| 622 suggestion = assertSuggestLocalConstructor('C.bar'); | |
| 623 expect(suggestion.element.parameters, '({dynamic boo, int z})'); | |
| 624 expect(suggestion.element.returnType, 'C'); | |
| 625 expect(suggestion.declaringType, 'C'); | |
| 626 expect(suggestion.parameterNames, hasLength(2)); | |
| 627 expect(suggestion.parameterNames[0], 'boo'); | |
| 628 expect(suggestion.parameterTypes[0], 'dynamic'); | |
| 629 expect(suggestion.parameterNames[1], 'z'); | |
| 630 expect(suggestion.parameterTypes[1], 'int'); | |
| 631 expect(suggestion.requiredParameterCount, 0); | |
| 632 expect(suggestion.hasNamedParameters, true); | |
| 633 }); | |
| 634 } | |
| 635 | |
| 636 test_method_parameters_mixed_required_and_named() { | |
| 637 addTestSource(''' | |
| 638 class A { | |
| 639 void m(x, {int y}) {} | |
| 640 } | |
| 641 class B extends A { | |
| 642 main() {^} | |
| 643 } | |
| 644 '''); | |
| 645 expect(computeFast(), isTrue); | |
| 646 CompletionSuggestion suggestion = | |
| 647 assertSuggestLocalMethod('m', 'A', 'void'); | |
| 648 expect(suggestion.parameterNames, hasLength(2)); | |
| 649 expect(suggestion.parameterNames[0], 'x'); | |
| 650 expect(suggestion.parameterTypes[0], 'dynamic'); | |
| 651 expect(suggestion.parameterNames[1], 'y'); | |
| 652 expect(suggestion.parameterTypes[1], 'int'); | |
| 653 expect(suggestion.requiredParameterCount, 1); | |
| 654 expect(suggestion.hasNamedParameters, true); | |
| 655 } | |
| 656 | |
| 657 test_method_parameters_mixed_required_and_positional() { | |
| 658 addTestSource(''' | |
| 659 class A { | |
| 660 void m(x, [int y]) {} | |
| 661 } | |
| 662 class B extends A { | |
| 663 main() {^} | |
| 664 } | |
| 665 '''); | |
| 666 expect(computeFast(), isTrue); | |
| 667 CompletionSuggestion suggestion = | |
| 668 assertSuggestLocalMethod('m', 'A', 'void'); | |
| 669 expect(suggestion.parameterNames, hasLength(2)); | |
| 670 expect(suggestion.parameterNames[0], 'x'); | |
| 671 expect(suggestion.parameterTypes[0], 'dynamic'); | |
| 672 expect(suggestion.parameterNames[1], 'y'); | |
| 673 expect(suggestion.parameterTypes[1], 'int'); | |
| 674 expect(suggestion.requiredParameterCount, 1); | |
| 675 expect(suggestion.hasNamedParameters, false); | |
| 676 } | |
| 677 | |
| 678 test_method_parameters_named() { | |
| 679 addTestSource(''' | |
| 680 class A { | |
| 681 void m({x, int y}) {} | |
| 682 } | |
| 683 class B extends A { | |
| 684 main() {^} | |
| 685 } | |
| 686 '''); | |
| 687 expect(computeFast(), isTrue); | |
| 688 CompletionSuggestion suggestion = | |
| 689 assertSuggestLocalMethod('m', 'A', 'void'); | |
| 690 expect(suggestion.parameterNames, hasLength(2)); | |
| 691 expect(suggestion.parameterNames[0], 'x'); | |
| 692 expect(suggestion.parameterTypes[0], 'dynamic'); | |
| 693 expect(suggestion.parameterNames[1], 'y'); | |
| 694 expect(suggestion.parameterTypes[1], 'int'); | |
| 695 expect(suggestion.requiredParameterCount, 0); | |
| 696 expect(suggestion.hasNamedParameters, true); | |
| 697 } | |
| 698 | |
| 699 test_method_parameters_none() { | |
| 700 addTestSource(''' | |
| 701 class A { | |
| 702 void m() {} | |
| 703 } | |
| 704 class B extends A { | |
| 705 main() {^} | |
| 706 } | |
| 707 '''); | |
| 708 expect(computeFast(), isTrue); | |
| 709 CompletionSuggestion suggestion = | |
| 710 assertSuggestLocalMethod('m', 'A', 'void'); | |
| 711 expect(suggestion.parameterNames, isEmpty); | |
| 712 expect(suggestion.parameterTypes, isEmpty); | |
| 713 expect(suggestion.requiredParameterCount, 0); | |
| 714 expect(suggestion.hasNamedParameters, false); | |
| 715 } | |
| 716 | |
| 717 test_method_parameters_positional() { | |
| 718 addTestSource(''' | |
| 719 class A { | |
| 720 void m([x, int y]) {} | |
| 721 } | |
| 722 class B extends A { | |
| 723 main() {^} | |
| 724 } | |
| 725 '''); | |
| 726 expect(computeFast(), isTrue); | |
| 727 CompletionSuggestion suggestion = | |
| 728 assertSuggestLocalMethod('m', 'A', 'void'); | |
| 729 expect(suggestion.parameterNames, hasLength(2)); | |
| 730 expect(suggestion.parameterNames[0], 'x'); | |
| 731 expect(suggestion.parameterTypes[0], 'dynamic'); | |
| 732 expect(suggestion.parameterNames[1], 'y'); | |
| 733 expect(suggestion.parameterTypes[1], 'int'); | |
| 734 expect(suggestion.requiredParameterCount, 0); | |
| 735 expect(suggestion.hasNamedParameters, false); | |
| 736 } | |
| 737 | |
| 738 test_method_parameters_required() { | |
| 739 addTestSource(''' | |
| 740 class A { | |
| 741 void m(x, int y) {} | |
| 742 } | |
| 743 class B extends A { | |
| 744 main() {^} | |
| 745 } | |
| 746 '''); | |
| 747 expect(computeFast(), isTrue); | |
| 748 CompletionSuggestion suggestion = | |
| 749 assertSuggestLocalMethod('m', 'A', 'void'); | |
| 750 expect(suggestion.parameterNames, hasLength(2)); | |
| 751 expect(suggestion.parameterNames[0], 'x'); | |
| 752 expect(suggestion.parameterTypes[0], 'dynamic'); | |
| 753 expect(suggestion.parameterNames[1], 'y'); | |
| 754 expect(suggestion.parameterTypes[1], 'int'); | |
| 755 expect(suggestion.requiredParameterCount, 2); | |
| 756 expect(suggestion.hasNamedParameters, false); | |
| 757 } | |
| 758 | |
| 759 test_overrides() { | |
| 760 addTestSource(''' | |
| 761 class A {m() {}} | |
| 762 class B extends A {m() {^}} | |
| 763 '''); | |
| 764 expect(computeFast(), isTrue); | |
| 765 assertSuggestMethod('m', 'B', null, relevance: DART_RELEVANCE_LOCAL_METHOD); | |
| 766 } | |
| 767 | |
| 768 test_shadowed_name() { | |
| 769 addTestSource('var a; class A { var a; m() { ^ } }'); | |
| 770 expect(computeFast(), isTrue); | |
| 771 assertSuggestLocalField('a', null); | |
| 772 } | |
| 773 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1068483002:
rename completion source files to match content (Closed)
Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart