OLD | NEW |
1 // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file | 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 | 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. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 library analyzer.test.generated.parser_test; | |
6 | |
7 import 'package:analyzer/dart/ast/ast.dart'; | 5 import 'package:analyzer/dart/ast/ast.dart'; |
8 import 'package:analyzer/dart/ast/standard_ast_factory.dart'; | 6 import 'package:analyzer/dart/ast/standard_ast_factory.dart'; |
9 import 'package:analyzer/dart/ast/token.dart'; | 7 import 'package:analyzer/dart/ast/token.dart'; |
10 import 'package:analyzer/dart/ast/visitor.dart'; | 8 import 'package:analyzer/dart/ast/visitor.dart'; |
11 import 'package:analyzer/error/error.dart'; | 9 import 'package:analyzer/error/error.dart'; |
12 import 'package:analyzer/error/listener.dart'; | 10 import 'package:analyzer/error/listener.dart'; |
13 import 'package:analyzer/src/dart/ast/token.dart'; | 11 import 'package:analyzer/src/dart/ast/token.dart'; |
14 import 'package:analyzer/src/dart/scanner/reader.dart'; | 12 import 'package:analyzer/src/dart/scanner/reader.dart'; |
15 import 'package:analyzer/src/dart/scanner/scanner.dart'; | 13 import 'package:analyzer/src/dart/scanner/scanner.dart'; |
16 import 'package:analyzer/src/generated/parser.dart'; | 14 import 'package:analyzer/src/generated/parser.dart'; |
(...skipping 604 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
621 expect(method.modifierKeyword, isNull); | 619 expect(method.modifierKeyword, isNull); |
622 expect(method.propertyKeyword, isNull); | 620 expect(method.propertyKeyword, isNull); |
623 expect(method.returnType, isNull); | 621 expect(method.returnType, isNull); |
624 expect(method.name, isNotNull); | 622 expect(method.name, isNotNull); |
625 expect(method.operatorKeyword, isNull); | 623 expect(method.operatorKeyword, isNull); |
626 expect(method.typeParameters, isNotNull); | 624 expect(method.typeParameters, isNotNull); |
627 expect(method.parameters, isNotNull); | 625 expect(method.parameters, isNotNull); |
628 expect(method.body, isNotNull); | 626 expect(method.body, isNotNull); |
629 } | 627 } |
630 | 628 |
631 void test_parseClassMember_method_generic_comment_returnType() { | 629 void test_parseClassMember_method_generic_comment_parameterType() { |
632 enableGenericMethodComments = true; | 630 enableGenericMethodComments = true; |
633 createParser('/*=T*/ m/*<T>*/() {}'); | 631 createParser('m/*<T>*/(dynamic /*=T*/ p) => null;'); |
634 ClassMember member = parser.parseClassMember('C'); | 632 ClassMember member = parser.parseClassMember('C'); |
635 expect(member, isNotNull); | 633 expect(member, isNotNull); |
636 assertNoErrors(); | 634 assertNoErrors(); |
637 expect(member, new isInstanceOf<MethodDeclaration>()); | 635 expect(member, new isInstanceOf<MethodDeclaration>()); |
638 MethodDeclaration method = member; | 636 MethodDeclaration method = member; |
639 expect(method.documentationComment, isNull); | 637 expect(method.documentationComment, isNull); |
640 expect(method.externalKeyword, isNull); | 638 expect(method.externalKeyword, isNull); |
641 expect(method.modifierKeyword, isNull); | 639 expect(method.modifierKeyword, isNull); |
642 expect(method.propertyKeyword, isNull); | 640 expect(method.propertyKeyword, isNull); |
643 expect(method.returnType, isNotNull); | 641 expect(method.returnType, isNull); |
644 expect((method.returnType as TypeName).name.name, 'T'); | |
645 expect(method.name, isNotNull); | 642 expect(method.name, isNotNull); |
646 expect(method.operatorKeyword, isNull); | 643 expect(method.operatorKeyword, isNull); |
647 expect(method.typeParameters, isNotNull); | 644 expect(method.typeParameters, isNotNull); |
648 expect(method.parameters, isNotNull); | 645 |
| 646 FormalParameterList parameters = method.parameters; |
| 647 expect(parameters, isNotNull); |
| 648 expect(parameters.parameters, hasLength(1)); |
| 649 var parameter = parameters.parameters[0] as SimpleFormalParameter; |
| 650 var parameterType = parameter.type as TypeName; |
| 651 expect(parameterType.name.name, 'T'); |
| 652 |
649 expect(method.body, isNotNull); | 653 expect(method.body, isNotNull); |
650 } | 654 } |
651 | 655 |
652 void test_parseClassMember_method_static_generic_comment_returnType() { | 656 void test_parseClassMember_method_generic_comment_returnType() { |
653 enableGenericMethodComments = true; | 657 enableGenericMethodComments = true; |
654 createParser('static /*=T*/ m/*<T>*/() {}'); | 658 createParser('/*=T*/ m/*<T>*/() {}'); |
655 ClassMember member = parser.parseClassMember('C'); | 659 ClassMember member = parser.parseClassMember('C'); |
656 expect(member, isNotNull); | 660 expect(member, isNotNull); |
657 assertNoErrors(); | 661 assertNoErrors(); |
658 expect(member, new isInstanceOf<MethodDeclaration>()); | 662 expect(member, new isInstanceOf<MethodDeclaration>()); |
659 MethodDeclaration method = member; | 663 MethodDeclaration method = member; |
660 expect(method.documentationComment, isNull); | 664 expect(method.documentationComment, isNull); |
661 expect(method.externalKeyword, isNull); | 665 expect(method.externalKeyword, isNull); |
662 expect(method.modifierKeyword, isNotNull); | 666 expect(method.modifierKeyword, isNull); |
663 expect(method.propertyKeyword, isNull); | 667 expect(method.propertyKeyword, isNull); |
664 expect(method.returnType, isNotNull); | 668 expect(method.returnType, isNotNull); |
665 expect((method.returnType as TypeName).name.name, 'T'); | 669 expect((method.returnType as TypeName).name.name, 'T'); |
666 expect(method.name, isNotNull); | 670 expect(method.name, isNotNull); |
667 expect(method.operatorKeyword, isNull); | 671 expect(method.operatorKeyword, isNull); |
668 expect(method.typeParameters, isNotNull); | 672 expect(method.typeParameters, isNotNull); |
669 expect(method.parameters, isNotNull); | 673 expect(method.parameters, isNotNull); |
670 expect(method.body, isNotNull); | 674 expect(method.body, isNotNull); |
671 } | 675 } |
672 | 676 |
673 void test_parseClassMember_method_generic_comment_returnType_complex() { | 677 void test_parseClassMember_method_generic_comment_returnType_bound() { |
674 enableGenericMethodComments = true; | 678 enableGenericMethodComments = true; |
675 createParser('dynamic /*=Map<int, T>*/ m/*<T>*/() => null;'); | 679 createParser('num/*=T*/ m/*<T extends num>*/() {}'); |
676 ClassMember member = parser.parseClassMember('C'); | 680 ClassMember member = parser.parseClassMember('C'); |
677 expect(member, isNotNull); | 681 expect(member, isNotNull); |
678 assertNoErrors(); | 682 assertNoErrors(); |
679 expect(member, new isInstanceOf<MethodDeclaration>()); | 683 expect(member, new isInstanceOf<MethodDeclaration>()); |
680 MethodDeclaration method = member; | 684 MethodDeclaration method = member; |
681 expect(method.documentationComment, isNull); | 685 expect(method.documentationComment, isNull); |
682 expect(method.externalKeyword, isNull); | 686 expect(method.externalKeyword, isNull); |
683 expect(method.modifierKeyword, isNull); | 687 expect(method.modifierKeyword, isNull); |
684 expect(method.propertyKeyword, isNull); | 688 expect(method.propertyKeyword, isNull); |
685 | 689 expect((method.returnType as TypeName).name.name, 'T'); |
686 { | |
687 var returnType = method.returnType as TypeName; | |
688 expect(returnType, isNotNull); | |
689 expect(returnType.name.name, 'Map'); | |
690 | |
691 List<TypeAnnotation> typeArguments = returnType.typeArguments.arguments; | |
692 expect(typeArguments, hasLength(2)); | |
693 expect((typeArguments[0] as TypeName).name.name, 'int'); | |
694 expect((typeArguments[1] as TypeName).name.name, 'T'); | |
695 } | |
696 | |
697 expect(method.name, isNotNull); | 690 expect(method.name, isNotNull); |
698 expect(method.operatorKeyword, isNull); | 691 expect(method.operatorKeyword, isNull); |
699 expect(method.typeParameters, isNotNull); | 692 expect(method.typeParameters, isNotNull); |
| 693 TypeParameter tp = method.typeParameters.typeParameters[0]; |
| 694 expect(tp.name.name, 'T'); |
| 695 expect(tp.extendsKeyword, isNotNull); |
| 696 expect((tp.bound as TypeName).name.name, 'num'); |
700 expect(method.parameters, isNotNull); | 697 expect(method.parameters, isNotNull); |
701 expect(method.body, isNotNull); | 698 expect(method.body, isNotNull); |
702 } | 699 } |
703 | 700 |
704 void test_parseClassMember_method_generic_comment_parameterType() { | 701 void test_parseClassMember_method_generic_comment_returnType_complex() { |
705 enableGenericMethodComments = true; | 702 enableGenericMethodComments = true; |
706 createParser('m/*<T>*/(dynamic /*=T*/ p) => null;'); | 703 createParser('dynamic /*=Map<int, T>*/ m/*<T>*/() => null;'); |
707 ClassMember member = parser.parseClassMember('C'); | 704 ClassMember member = parser.parseClassMember('C'); |
708 expect(member, isNotNull); | 705 expect(member, isNotNull); |
709 assertNoErrors(); | 706 assertNoErrors(); |
710 expect(member, new isInstanceOf<MethodDeclaration>()); | 707 expect(member, new isInstanceOf<MethodDeclaration>()); |
711 MethodDeclaration method = member; | 708 MethodDeclaration method = member; |
712 expect(method.documentationComment, isNull); | 709 expect(method.documentationComment, isNull); |
713 expect(method.externalKeyword, isNull); | 710 expect(method.externalKeyword, isNull); |
714 expect(method.modifierKeyword, isNull); | 711 expect(method.modifierKeyword, isNull); |
715 expect(method.propertyKeyword, isNull); | 712 expect(method.propertyKeyword, isNull); |
716 expect(method.returnType, isNull); | 713 |
| 714 { |
| 715 var returnType = method.returnType as TypeName; |
| 716 expect(returnType, isNotNull); |
| 717 expect(returnType.name.name, 'Map'); |
| 718 |
| 719 List<TypeAnnotation> typeArguments = returnType.typeArguments.arguments; |
| 720 expect(typeArguments, hasLength(2)); |
| 721 expect((typeArguments[0] as TypeName).name.name, 'int'); |
| 722 expect((typeArguments[1] as TypeName).name.name, 'T'); |
| 723 } |
| 724 |
717 expect(method.name, isNotNull); | 725 expect(method.name, isNotNull); |
718 expect(method.operatorKeyword, isNull); | 726 expect(method.operatorKeyword, isNull); |
719 expect(method.typeParameters, isNotNull); | 727 expect(method.typeParameters, isNotNull); |
720 | |
721 FormalParameterList parameters = method.parameters; | |
722 expect(parameters, isNotNull); | |
723 expect(parameters.parameters, hasLength(1)); | |
724 var parameter = parameters.parameters[0] as SimpleFormalParameter; | |
725 var parameterType = parameter.type as TypeName; | |
726 expect(parameterType.name.name, 'T'); | |
727 | |
728 expect(method.body, isNotNull); | |
729 } | |
730 | |
731 void test_parseClassMember_method_generic_comment_returnType_bound() { | |
732 enableGenericMethodComments = true; | |
733 createParser('num/*=T*/ m/*<T extends num>*/() {}'); | |
734 ClassMember member = parser.parseClassMember('C'); | |
735 expect(member, isNotNull); | |
736 assertNoErrors(); | |
737 expect(member, new isInstanceOf<MethodDeclaration>()); | |
738 MethodDeclaration method = member; | |
739 expect(method.documentationComment, isNull); | |
740 expect(method.externalKeyword, isNull); | |
741 expect(method.modifierKeyword, isNull); | |
742 expect(method.propertyKeyword, isNull); | |
743 expect((method.returnType as TypeName).name.name, 'T'); | |
744 expect(method.name, isNotNull); | |
745 expect(method.operatorKeyword, isNull); | |
746 expect(method.typeParameters, isNotNull); | |
747 TypeParameter tp = method.typeParameters.typeParameters[0]; | |
748 expect(tp.name.name, 'T'); | |
749 expect(tp.extendsKeyword, isNotNull); | |
750 expect((tp.bound as TypeName).name.name, 'num'); | |
751 expect(method.parameters, isNotNull); | 728 expect(method.parameters, isNotNull); |
752 expect(method.body, isNotNull); | 729 expect(method.body, isNotNull); |
753 } | 730 } |
754 | 731 |
755 void test_parseClassMember_method_generic_comment_void() { | 732 void test_parseClassMember_method_generic_comment_void() { |
756 enableGenericMethodComments = true; | 733 enableGenericMethodComments = true; |
757 createParser('void m/*<T>*/() {}'); | 734 createParser('void m/*<T>*/() {}'); |
758 ClassMember member = parser.parseClassMember('C'); | 735 ClassMember member = parser.parseClassMember('C'); |
759 expect(member, isNotNull); | 736 expect(member, isNotNull); |
760 assertNoErrors(); | 737 assertNoErrors(); |
(...skipping 304 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1065 expect(method.modifierKeyword, isNull); | 1042 expect(method.modifierKeyword, isNull); |
1066 expect(method.propertyKeyword, isNull); | 1043 expect(method.propertyKeyword, isNull); |
1067 expect(method.returnType, isNotNull); | 1044 expect(method.returnType, isNotNull); |
1068 expect(method.name, isNotNull); | 1045 expect(method.name, isNotNull); |
1069 expect(method.operatorKeyword, isNull); | 1046 expect(method.operatorKeyword, isNull); |
1070 expect(method.typeParameters, isNull); | 1047 expect(method.typeParameters, isNull); |
1071 expect(method.parameters, isNotNull); | 1048 expect(method.parameters, isNotNull); |
1072 expect(method.body, isNotNull); | 1049 expect(method.body, isNotNull); |
1073 } | 1050 } |
1074 | 1051 |
| 1052 void test_parseClassMember_method_static_generic_comment_returnType() { |
| 1053 enableGenericMethodComments = true; |
| 1054 createParser('static /*=T*/ m/*<T>*/() {}'); |
| 1055 ClassMember member = parser.parseClassMember('C'); |
| 1056 expect(member, isNotNull); |
| 1057 assertNoErrors(); |
| 1058 expect(member, new isInstanceOf<MethodDeclaration>()); |
| 1059 MethodDeclaration method = member; |
| 1060 expect(method.documentationComment, isNull); |
| 1061 expect(method.externalKeyword, isNull); |
| 1062 expect(method.modifierKeyword, isNotNull); |
| 1063 expect(method.propertyKeyword, isNull); |
| 1064 expect(method.returnType, isNotNull); |
| 1065 expect((method.returnType as TypeName).name.name, 'T'); |
| 1066 expect(method.name, isNotNull); |
| 1067 expect(method.operatorKeyword, isNull); |
| 1068 expect(method.typeParameters, isNotNull); |
| 1069 expect(method.parameters, isNotNull); |
| 1070 expect(method.body, isNotNull); |
| 1071 } |
| 1072 |
1075 void test_parseClassMember_method_trailing_commas() { | 1073 void test_parseClassMember_method_trailing_commas() { |
1076 createParser('void f(int x, int y,) {}'); | 1074 createParser('void f(int x, int y,) {}'); |
1077 ClassMember member = parser.parseClassMember('C'); | 1075 ClassMember member = parser.parseClassMember('C'); |
1078 expect(member, isNotNull); | 1076 expect(member, isNotNull); |
1079 assertNoErrors(); | 1077 assertNoErrors(); |
1080 expect(member, new isInstanceOf<MethodDeclaration>()); | 1078 expect(member, new isInstanceOf<MethodDeclaration>()); |
1081 MethodDeclaration method = member; | 1079 MethodDeclaration method = member; |
1082 expect(method.documentationComment, isNull); | 1080 expect(method.documentationComment, isNull); |
1083 expect(method.externalKeyword, isNull); | 1081 expect(method.externalKeyword, isNull); |
1084 expect(method.modifierKeyword, isNull); | 1082 expect(method.modifierKeyword, isNull); |
(...skipping 1769 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2854 void test_functionTypedParameter_const() { | 2852 void test_functionTypedParameter_const() { |
2855 parseCompilationUnit( | 2853 parseCompilationUnit( |
2856 "void f(const x()) {}", [ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR]); | 2854 "void f(const x()) {}", [ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR]); |
2857 } | 2855 } |
2858 | 2856 |
2859 void test_functionTypedParameter_final() { | 2857 void test_functionTypedParameter_final() { |
2860 parseCompilationUnit( | 2858 parseCompilationUnit( |
2861 "void f(final x()) {}", [ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR]); | 2859 "void f(final x()) {}", [ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR]); |
2862 } | 2860 } |
2863 | 2861 |
| 2862 void test_functionTypedParameter_incomplete1() { |
| 2863 // This caused an exception at one point. |
| 2864 parseCompilationUnit("void f(int Function(", [ |
| 2865 ParserErrorCode.MISSING_FUNCTION_BODY, |
| 2866 ParserErrorCode.MISSING_CLOSING_PARENTHESIS, |
| 2867 ParserErrorCode.EXPECTED_EXECUTABLE, |
| 2868 ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE, |
| 2869 ParserErrorCode.EXPECTED_TOKEN, |
| 2870 ParserErrorCode.EXPECTED_TOKEN |
| 2871 ]); |
| 2872 } |
| 2873 |
2864 void test_functionTypedParameter_var() { | 2874 void test_functionTypedParameter_var() { |
2865 parseCompilationUnit( | 2875 parseCompilationUnit( |
2866 "void f(var x()) {}", [ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR]); | 2876 "void f(var x()) {}", [ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR]); |
2867 } | 2877 } |
2868 | 2878 |
2869 void test_getterInFunction_block_noReturnType() { | 2879 void test_getterInFunction_block_noReturnType() { |
2870 FunctionDeclarationStatement statement = | 2880 FunctionDeclarationStatement statement = |
2871 parseStatement("get x { return _x; }"); | 2881 parseStatement("get x { return _x; }"); |
2872 assertErrorsWithCodes([ParserErrorCode.GETTER_IN_FUNCTION]); | 2882 assertErrorsWithCodes([ParserErrorCode.GETTER_IN_FUNCTION]); |
2873 expect(statement.functionDeclaration.functionExpression.parameters, isNull); | 2883 expect(statement.functionDeclaration.functionExpression.parameters, isNull); |
(...skipping 11670 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
14544 expect((declaration.returnType as TypeName).name.name, 'T'); | 14554 expect((declaration.returnType as TypeName).name.name, 'T'); |
14545 expect(declaration.name, isNotNull); | 14555 expect(declaration.name, isNotNull); |
14546 FunctionExpression expression = declaration.functionExpression; | 14556 FunctionExpression expression = declaration.functionExpression; |
14547 expect(expression, isNotNull); | 14557 expect(expression, isNotNull); |
14548 expect(expression.body, isNotNull); | 14558 expect(expression.body, isNotNull); |
14549 expect(expression.typeParameters, isNull); | 14559 expect(expression.typeParameters, isNull); |
14550 expect(expression.parameters, isNull); | 14560 expect(expression.parameters, isNull); |
14551 expect(declaration.propertyKeyword, isNotNull); | 14561 expect(declaration.propertyKeyword, isNotNull); |
14552 } | 14562 } |
14553 | 14563 |
14554 void test_parseFunctionDeclaration_setter() { | |
14555 createParser('/// Doc\nT set p(v) {}'); | |
14556 FunctionDeclaration declaration = parseFullCompilationUnitMember(); | |
14557 expect(declaration, isNotNull); | |
14558 assertNoErrors(); | |
14559 expectCommentText(declaration.documentationComment, '/// Doc'); | |
14560 expect((declaration.returnType as TypeName).name.name, 'T'); | |
14561 expect(declaration.name, isNotNull); | |
14562 FunctionExpression expression = declaration.functionExpression; | |
14563 expect(expression, isNotNull); | |
14564 expect(expression.body, isNotNull); | |
14565 expect(expression.typeParameters, isNull); | |
14566 expect(expression.parameters, isNotNull); | |
14567 expect(declaration.propertyKeyword, isNotNull); | |
14568 } | |
14569 | |
14570 void test_parseFunctionDeclaration_getter_generic_comment_returnType() { | 14564 void test_parseFunctionDeclaration_getter_generic_comment_returnType() { |
14571 enableGenericMethodComments = true; | 14565 enableGenericMethodComments = true; |
14572 createParser('/*=T*/ f/*<S, T>*/(/*=S*/ s) => null;'); | 14566 createParser('/*=T*/ f/*<S, T>*/(/*=S*/ s) => null;'); |
14573 var member = parseFullCompilationUnitMember(); | 14567 var member = parseFullCompilationUnitMember(); |
14574 expect(member, isNotNull); | 14568 expect(member, isNotNull); |
14575 assertNoErrors(); | 14569 assertNoErrors(); |
14576 var functionDeclaration = member as FunctionDeclaration; | 14570 var functionDeclaration = member as FunctionDeclaration; |
14577 var functionExpression = functionDeclaration.functionExpression; | 14571 var functionExpression = functionDeclaration.functionExpression; |
14578 expect(functionDeclaration.documentationComment, isNull); | 14572 expect(functionDeclaration.documentationComment, isNull); |
14579 expect(functionDeclaration.externalKeyword, isNull); | 14573 expect(functionDeclaration.externalKeyword, isNull); |
14580 expect(functionDeclaration.propertyKeyword, isNull); | 14574 expect(functionDeclaration.propertyKeyword, isNull); |
14581 expect((functionDeclaration.returnType as TypeName).name.name, 'T'); | 14575 expect((functionDeclaration.returnType as TypeName).name.name, 'T'); |
14582 expect(functionDeclaration.name, isNotNull); | 14576 expect(functionDeclaration.name, isNotNull); |
14583 expect(functionExpression.typeParameters, isNotNull); | 14577 expect(functionExpression.typeParameters, isNotNull); |
14584 expect(functionExpression.parameters, isNotNull); | 14578 expect(functionExpression.parameters, isNotNull); |
14585 expect(functionExpression.body, isNotNull); | 14579 expect(functionExpression.body, isNotNull); |
14586 } | 14580 } |
14587 | 14581 |
| 14582 void test_parseFunctionDeclaration_setter() { |
| 14583 createParser('/// Doc\nT set p(v) {}'); |
| 14584 FunctionDeclaration declaration = parseFullCompilationUnitMember(); |
| 14585 expect(declaration, isNotNull); |
| 14586 assertNoErrors(); |
| 14587 expectCommentText(declaration.documentationComment, '/// Doc'); |
| 14588 expect((declaration.returnType as TypeName).name.name, 'T'); |
| 14589 expect(declaration.name, isNotNull); |
| 14590 FunctionExpression expression = declaration.functionExpression; |
| 14591 expect(expression, isNotNull); |
| 14592 expect(expression.body, isNotNull); |
| 14593 expect(expression.typeParameters, isNull); |
| 14594 expect(expression.parameters, isNotNull); |
| 14595 expect(declaration.propertyKeyword, isNotNull); |
| 14596 } |
| 14597 |
14588 @failingTest | 14598 @failingTest |
14589 void test_parseGenericTypeAlias_noTypeParameters() { | 14599 void test_parseGenericTypeAlias_noTypeParameters() { |
14590 createParser('F = int Function(int);'); | 14600 createParser('F = int Function(int);'); |
14591 GenericTypeAlias alias = parseFullCompilationUnitMember(); | 14601 GenericTypeAlias alias = parseFullCompilationUnitMember(); |
14592 expect(alias, isNotNull); | 14602 expect(alias, isNotNull); |
14593 assertNoErrors(); | 14603 assertNoErrors(); |
14594 expect(alias.name, isNotNull); | 14604 expect(alias.name, isNotNull); |
14595 expect(alias.name.name, 'F'); | 14605 expect(alias.name.name, 'F'); |
14596 expect(alias.typeParameters, isNull); | 14606 expect(alias.typeParameters, isNull); |
14597 expect(alias.equals, isNotNull); | 14607 expect(alias.equals, isNotNull); |
(...skipping 476 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
15074 expectCommentText(typeVariable.documentationComment, '/// Doc'); | 15084 expectCommentText(typeVariable.documentationComment, '/// Doc'); |
15075 } | 15085 } |
15076 | 15086 |
15077 /** | 15087 /** |
15078 * Assert that the given [name] is in declaration context. | 15088 * Assert that the given [name] is in declaration context. |
15079 */ | 15089 */ |
15080 void _assertIsDeclarationName(SimpleIdentifier name) { | 15090 void _assertIsDeclarationName(SimpleIdentifier name) { |
15081 expect(name.inDeclarationContext(), isTrue); | 15091 expect(name.inDeclarationContext(), isTrue); |
15082 } | 15092 } |
15083 } | 15093 } |
OLD | NEW |