languages/dart-sdk
languages/dart-sdk
1
0
Fork 0
mirror of https://github.com/dart-lang/sdk synced 2024-10-02 23:49:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

Enforce uniqueness of ErrorCode.uniqueName

Browse source 
Remove duplicate ParserErrorCode(s).

R=brianwilkerson@google.com

Change-Id: I8c8e4e3433f7147a728888cf5735bbecbc8297c1
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/158204
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>
Commit-Queue: Konstantin Shcheglov <scheglov@google.com>
This commit is contained in:
Konstantin Shcheglov 2020-08-12 00:40:59 +00:00 committed by commit-bot@chromium.org
parent 274b4d3ecb
commit 022812983e
8 changed files with 64 additions and 93 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
pkg/analyzer/lib/error/error.dart
View file

@ -585,10 +585,7 @@ const List<ErrorCode> errorCodeValues = [
ParserErrorCode.CLASS_IN_CLASS,
ParserErrorCode.COLON_IN_PLACE_OF_IN,
ParserErrorCode.CONFLICTING_MODIFIERS,
ParserErrorCode.CONST_AFTER_FACTORY,
ParserErrorCode.CONST_AND_COVARIANT,
ParserErrorCode.CONST_AND_FINAL,
ParserErrorCode.CONST_AND_VAR,
ParserErrorCode.CONST_CLASS,
ParserErrorCode.CONST_CONSTRUCTOR_WITH_BODY,
ParserErrorCode.CONST_ENUM,
@ -598,8 +595,6 @@ const List<ErrorCode> errorCodeValues = [
ParserErrorCode.CONSTRUCTOR_WITH_RETURN_TYPE,
ParserErrorCode.CONTINUE_OUTSIDE_OF_LOOP,
ParserErrorCode.CONTINUE_WITHOUT_LABEL_IN_CASE,
ParserErrorCode.COVARIANT_AFTER_FINAL,
ParserErrorCode.COVARIANT_AFTER_VAR,
ParserErrorCode.COVARIANT_AND_STATIC,
ParserErrorCode.COVARIANT_CONSTRUCTOR,
ParserErrorCode.COVARIANT_MEMBER,
@ -629,9 +624,6 @@ const List<ErrorCode> errorCodeValues = [
ParserErrorCode.EXTENSION_DECLARES_ABSTRACT_MEMBER,
ParserErrorCode.EXTENSION_DECLARES_CONSTRUCTOR,
ParserErrorCode.EXTENSION_DECLARES_INSTANCE_FIELD,
ParserErrorCode.EXTERNAL_AFTER_CONST,
ParserErrorCode.EXTERNAL_AFTER_FACTORY,
ParserErrorCode.EXTERNAL_AFTER_STATIC,
ParserErrorCode.EXTERNAL_CLASS,
ParserErrorCode.EXTERNAL_CONSTRUCTOR_WITH_BODY,
ParserErrorCode.EXTERNAL_CONSTRUCTOR_WITH_INITIALIZER,
@ -691,7 +683,6 @@ const List<ErrorCode> errorCodeValues = [
ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR,
ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER,
ParserErrorCode.MISSING_CATCH_OR_FINALLY,
ParserErrorCode.MISSING_CLASS_BODY,
ParserErrorCode.MISSING_CLOSING_PARENTHESIS,
ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE,
ParserErrorCode.MISSING_ENUM_BODY,
@ -748,9 +739,6 @@ const List<ErrorCode> errorCodeValues = [
ParserErrorCode.SETTER_CONSTRUCTOR,
ParserErrorCode.SETTER_IN_FUNCTION,
ParserErrorCode.STACK_OVERFLOW,
ParserErrorCode.STATIC_AFTER_CONST,
ParserErrorCode.STATIC_AFTER_FINAL,
ParserErrorCode.STATIC_AFTER_VAR,
ParserErrorCode.STATIC_CONSTRUCTOR,
ParserErrorCode.STATIC_GETTER_WITHOUT_BODY,
ParserErrorCode.STATIC_OPERATOR,
@ -821,7 +809,14 @@ ErrorCode errorCodeByUniqueName(String uniqueName) {
if (_uniqueNameToCodeMap == null) {
_uniqueNameToCodeMap = HashMap<String, ErrorCode>();
for (ErrorCode errorCode in errorCodeValues) {
_uniqueNameToCodeMap[errorCode.uniqueName] = errorCode;
var uniqueName = errorCode.uniqueName;
assert(() {
if (_uniqueNameToCodeMap.containsKey(uniqueName)) {
throw StateError('Not unique: $uniqueName');
}
return true;
}());
_uniqueNameToCodeMap[uniqueName] = errorCode;
}
}
return _uniqueNameToCodeMap[uniqueName];

28
pkg/analyzer/lib/src/dart/error/syntactic_errors.dart
View file

@ -79,17 +79,8 @@ class ParserErrorCode extends ErrorCode {
static const ParserErrorCode CONFLICTING_MODIFIERS = _CONFLICTING_MODIFIERS;
// TODO(danrubel): Remove this unused error code
static const ParserErrorCode CONST_AFTER_FACTORY = _MODIFIER_OUT_OF_ORDER;
// TODO(danrubel): Remove this unused error code
static const ParserErrorCode CONST_AND_COVARIANT = _CONFLICTING_MODIFIERS;
static const ParserErrorCode CONST_AND_FINAL = _CONST_AND_FINAL;
// TODO(danrubel): Remove this unused error code
static const ParserErrorCode CONST_AND_VAR = _CONFLICTING_MODIFIERS;
static const ParserErrorCode CONST_CLASS = _CONST_CLASS;
static const ParserErrorCode CONST_CONSTRUCTOR_WITH_BODY = ParserErrorCode(
@ -117,11 +108,6 @@ class ParserErrorCode extends ErrorCode {
static const ParserErrorCode CONTINUE_WITHOUT_LABEL_IN_CASE =
_CONTINUE_WITHOUT_LABEL_IN_CASE;
// TODO(danrubel): Remove this unused error code
static const ParserErrorCode COVARIANT_AFTER_FINAL = _MODIFIER_OUT_OF_ORDER;
static const ParserErrorCode COVARIANT_AFTER_VAR = _MODIFIER_OUT_OF_ORDER;
static const ParserErrorCode COVARIANT_AND_STATIC = _COVARIANT_AND_STATIC;
static const ParserErrorCode COVARIANT_CONSTRUCTOR = ParserErrorCode(
@ -294,12 +280,6 @@ class ParserErrorCode extends ErrorCode {
static const ParserErrorCode EXTENSION_DECLARES_INSTANCE_FIELD =
_EXTENSION_DECLARES_INSTANCE_FIELD;
static const ParserErrorCode EXTERNAL_AFTER_CONST = _MODIFIER_OUT_OF_ORDER;
static const ParserErrorCode EXTERNAL_AFTER_FACTORY = _MODIFIER_OUT_OF_ORDER;
static const ParserErrorCode EXTERNAL_AFTER_STATIC = _MODIFIER_OUT_OF_ORDER;
static const ParserErrorCode EXTERNAL_CLASS = _EXTERNAL_CLASS;
static const ParserErrorCode EXTERNAL_CONSTRUCTOR_WITH_BODY =
@ -544,8 +524,6 @@ class ParserErrorCode extends ErrorCode {
static const ParserErrorCode MISSING_CATCH_OR_FINALLY =
_MISSING_CATCH_OR_FINALLY;
static const ParserErrorCode MISSING_CLASS_BODY = _EXPECTED_BODY;
static const ParserErrorCode MISSING_CLOSING_PARENTHESIS = ParserErrorCode(
'MISSING_CLOSING_PARENTHESIS', "The closing parenthesis is missing.",
correction: "Try adding the closing parenthesis.");
@ -794,12 +772,6 @@ class ParserErrorCode extends ErrorCode {
static const ParserErrorCode STACK_OVERFLOW = _STACK_OVERFLOW;
static const ParserErrorCode STATIC_AFTER_CONST = _MODIFIER_OUT_OF_ORDER;
static const ParserErrorCode STATIC_AFTER_FINAL = _MODIFIER_OUT_OF_ORDER;
static const ParserErrorCode STATIC_AFTER_VAR = _MODIFIER_OUT_OF_ORDER;
static const ParserErrorCode STATIC_CONSTRUCTOR = _STATIC_CONSTRUCTOR;
static const ParserErrorCode STATIC_GETTER_WITHOUT_BODY = ParserErrorCode(

25
pkg/analyzer/lib/src/generated/parser.dart
View file

@ -1160,7 +1160,7 @@ class Parser {
// members until it is reached.
leftBracket = _createSyntheticToken(TokenType.OPEN_CURLY_BRACKET);
rightBracket = _createSyntheticToken(TokenType.CLOSE_CURLY_BRACKET);
_reportErrorForCurrentToken(ParserErrorCode.MISSING_CLASS_BODY);
_reportErrorForCurrentToken(ParserErrorCode.EXPECTED_BODY);
}
ClassDeclaration classDeclaration = astFactory.classDeclaration(
commentAndMetadata.comment,
@ -7729,13 +7729,13 @@ class Parser {
constKeyword != null &&
constKeyword.offset < externalKeyword.offset) {
_reportErrorForToken(
ParserErrorCode.EXTERNAL_AFTER_CONST, externalKeyword);
ParserErrorCode.MODIFIER_OUT_OF_ORDER, externalKeyword);
}
if (externalKeyword != null &&
factoryKeyword != null &&
factoryKeyword.offset < externalKeyword.offset) {
_reportErrorForToken(
ParserErrorCode.EXTERNAL_AFTER_FACTORY, externalKeyword);
ParserErrorCode.MODIFIER_OUT_OF_ORDER, externalKeyword);
}
return constKeyword;
}
@ -7785,16 +7785,17 @@ class Parser {
if (constKeyword != null) {
if (covariantKeyword != null) {
_reportErrorForToken(
ParserErrorCode.CONST_AND_COVARIANT, covariantKeyword);
ParserErrorCode.MODIFIER_OUT_OF_ORDER, covariantKeyword);
}
if (finalKeyword != null) {
_reportErrorForToken(ParserErrorCode.CONST_AND_FINAL, finalKeyword);
}
if (varKeyword != null) {
_reportErrorForToken(ParserErrorCode.CONST_AND_VAR, varKeyword);
_reportErrorForToken(ParserErrorCode.MODIFIER_OUT_OF_ORDER, varKeyword);
}
if (staticKeyword != null && constKeyword.offset < staticKeyword.offset) {
_reportErrorForToken(ParserErrorCode.STATIC_AFTER_CONST, staticKeyword);
_reportErrorForToken(
ParserErrorCode.MODIFIER_OUT_OF_ORDER, staticKeyword);
}
} else if (finalKeyword != null) {
if (covariantKeyword != null) {
@ -7805,16 +7806,18 @@ class Parser {
_reportErrorForToken(ParserErrorCode.FINAL_AND_VAR, varKeyword);
}
if (staticKeyword != null && finalKeyword.offset < staticKeyword.offset) {
_reportErrorForToken(ParserErrorCode.STATIC_AFTER_FINAL, staticKeyword);
_reportErrorForToken(
ParserErrorCode.MODIFIER_OUT_OF_ORDER, staticKeyword);
}
} else if (varKeyword != null) {
if (staticKeyword != null && varKeyword.offset < staticKeyword.offset) {
_reportErrorForToken(ParserErrorCode.STATIC_AFTER_VAR, staticKeyword);
_reportErrorForToken(
ParserErrorCode.MODIFIER_OUT_OF_ORDER, staticKeyword);
}
if (covariantKeyword != null &&
varKeyword.offset < covariantKeyword.offset) {
_reportErrorForToken(
ParserErrorCode.COVARIANT_AFTER_VAR, covariantKeyword);
ParserErrorCode.MODIFIER_OUT_OF_ORDER, covariantKeyword);
}
}
if (covariantKeyword != null && staticKeyword != null) {
@ -7870,7 +7873,7 @@ class Parser {
staticKeyword != null &&
staticKeyword.offset < externalKeyword.offset) {
_reportErrorForToken(
ParserErrorCode.EXTERNAL_AFTER_STATIC, externalKeyword);
ParserErrorCode.MODIFIER_OUT_OF_ORDER, externalKeyword);
}
}
@ -7957,7 +7960,7 @@ class Parser {
_reportErrorForToken(ParserErrorCode.CONST_AND_FINAL, finalKeyword);
}
if (varKeyword != null) {
_reportErrorForToken(ParserErrorCode.CONST_AND_VAR, varKeyword);
_reportErrorForToken(ParserErrorCode.MODIFIER_OUT_OF_ORDER, varKeyword);
}
} else if (finalKeyword != null) {
if (varKeyword != null) {

2
pkg/analyzer/test/generated/parser_fasta_test.dart
View file

@ -1814,7 +1814,7 @@ class C {}
var unit = parseCompilationUnit('extension E', errors: [
expectedError(ParserErrorCode.EXPECTED_TOKEN, 10, 1),
expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 11, 0),
expectedError(ParserErrorCode.MISSING_CLASS_BODY, 11, 0),
expectedError(ParserErrorCode.EXPECTED_BODY, 11, 0),
]);
expect(unit.declarations, hasLength(1));
var extension = unit.declarations[0] as ExtensionDeclaration;

35
pkg/analyzer/test/generated/parser_test.dart
View file

@ -2499,7 +2499,7 @@ mixin ErrorParserTestMixin implements AbstractParserTestCase {
ClassMember member = parser.parseClassMember('C');
expectNotNullIfNoErrors(member);
listener.assertErrors(
[expectedError(ParserErrorCode.CONST_AND_COVARIANT, 10, 5)]);
[expectedError(ParserErrorCode.CONFLICTING_MODIFIERS, 10, 5)]);
}
void test_constAndFinal() {
@ -2514,7 +2514,8 @@ mixin ErrorParserTestMixin implements AbstractParserTestCase {
createParser('const var x = null;');
ClassMember member = parser.parseClassMember('C');
expectNotNullIfNoErrors(member);
listener.assertErrors([expectedError(ParserErrorCode.CONST_AND_VAR, 6, 3)]);
listener.assertErrors(
[expectedError(ParserErrorCode.CONFLICTING_MODIFIERS, 6, 3)]);
}
void test_constClass() {
@ -2724,7 +2725,7 @@ mixin ErrorParserTestMixin implements AbstractParserTestCase {
ClassMember member = parser.parseClassMember('C');
expectNotNullIfNoErrors(member);
listener.assertErrors(
[expectedError(ParserErrorCode.COVARIANT_AFTER_VAR, 4, 9)]);
[expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 4, 9)]);
}
void test_covariantAndFinal() {
@ -2964,6 +2965,11 @@ class Foo {
]);
}
void test_expectedBody_class() {
parseCompilationUnit("class A class B {}",
errors: [expectedError(ParserErrorCode.EXPECTED_BODY, 6, 1)]);
}
void test_expectedCaseOrDefault() {
SwitchStatement statement = parseStatement('switch (e) {break;}');
expectNotNullIfNoErrors(statement);
@ -3269,7 +3275,7 @@ class Foo {
ClassMember member = parser.parseClassMember('C');
expectNotNullIfNoErrors(member);
listener.assertErrors(
[expectedError(ParserErrorCode.EXTERNAL_AFTER_CONST, 6, 8)]);
[expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 6, 8)]);
}
void test_externalAfterFactory() {
@ -3285,7 +3291,7 @@ class Foo {
ClassMember member = parser.parseClassMember('C');
expectNotNullIfNoErrors(member);
listener.assertErrors(
[expectedError(ParserErrorCode.EXTERNAL_AFTER_STATIC, 7, 8)]);
[expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 7, 8)]);
}
void test_externalClass() {
@ -3537,7 +3543,7 @@ class Foo {
expectNotNullIfNoErrors(member);
listener.assertErrors(usingFastaParser
? [
expectedError(ParserErrorCode.COVARIANT_AFTER_FINAL, 6, 9),
expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 6, 9),
expectedError(ParserErrorCode.FINAL_AND_COVARIANT, 6, 9)
]
: [expectedError(ParserErrorCode.FINAL_AND_COVARIANT, 6, 9)]);
@ -4435,11 +4441,6 @@ class Wrong<T> {
expect(statement, isNotNull);
}
void test_missingClassBody() {
parseCompilationUnit("class A class B {}",
errors: [expectedError(ParserErrorCode.MISSING_CLASS_BODY, 6, 1)]);
}
void test_missingClosingParenthesis() {
createParser('(int a, int b ;',
expectedEndOffset: 14 /* parsing ends at synthetic ')' */);
@ -5158,7 +5159,7 @@ class Wrong<T> {
ClassMember member = parser.parseClassMember('C');
expectNotNullIfNoErrors(member);
listener.assertErrors(
[expectedError(ParserErrorCode.STATIC_AFTER_FINAL, 6, 6)]);
[expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 6, 6)]);
}
void test_staticAfterFinal() {
@ -5167,11 +5168,11 @@ class Wrong<T> {
expectNotNullIfNoErrors(member);
if (usingFastaParser) {
listener.assertErrors([
expectedError(ParserErrorCode.STATIC_AFTER_CONST, 6, 6),
expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 6, 6),
expectedError(CompileTimeErrorCode.CONST_NOT_INITIALIZED, 17, 1)
]);
} else {
listener.assertErrorsWithCodes([ParserErrorCode.STATIC_AFTER_CONST]);
listener.assertErrorsWithCodes([ParserErrorCode.MODIFIER_OUT_OF_ORDER]);
}
}
@ -5179,8 +5180,8 @@ class Wrong<T> {
createParser('var static f;');
ClassMember member = parser.parseClassMember('C');
expectNotNullIfNoErrors(member);
listener
.assertErrors([expectedError(ParserErrorCode.STATIC_AFTER_VAR, 4, 6)]);
listener.assertErrors(
[expectedError(ParserErrorCode.MODIFIER_OUT_OF_ORDER, 4, 6)]);
}
void test_staticConstructor() {
@ -16275,7 +16276,7 @@ mixin TopLevelParserTestMixin implements AbstractParserTestCase {
: [
expectedError(ParserErrorCode.EXPECTED_TYPE_NAME, 18, 4),
expectedError(ParserErrorCode.EXPECTED_TOKEN, 18, 4),
expectedError(ParserErrorCode.MISSING_CLASS_BODY, 18, 4),
expectedError(ParserErrorCode.EXPECTED_BODY, 18, 4),
expectedError(ParserErrorCode.EXPECTED_EXECUTABLE, 22, 1),
expectedError(ParserErrorCode.EXPECTED_EXECUTABLE, 22, 1),
expectedError(ParserErrorCode.UNEXPECTED_TOKEN, 22, 1),

4
pkg/analyzer/test/src/fasta/recovery/code_order_test.dart
View file

@ -89,7 +89,7 @@ class UnrelatedClass extends Bar {}
testRecovery('''
class Foo extends CurrentlyTypingHere
class UnrelatedClass extends Bar {}
''', [ParserErrorCode.MISSING_CLASS_BODY], '''
''', [ParserErrorCode.EXPECTED_BODY], '''
class Foo extends CurrentlyTypingHere {}
class UnrelatedClass extends Bar {}
''');
@ -362,7 +362,7 @@ mixin UnrelatedMixin on Bar {}
testRecovery('''
mixin Foo implements CurrentlyTypingHere
mixin UnrelatedMixin on Bar {}
''', [ParserErrorCode.MISSING_CLASS_BODY], '''
''', [ParserErrorCode.EXPECTED_BODY], '''
mixin Foo implements CurrentlyTypingHere {}
mixin UnrelatedMixin on Bar {}
''');

22
pkg/analyzer/test/src/fasta/recovery/partial_code/class_declaration_test.dart
View file

@ -20,19 +20,19 @@ class ClassDeclarationTest extends PartialCodeTest {
'class',
[
ParserErrorCode.MISSING_IDENTIFIER,
ParserErrorCode.MISSING_CLASS_BODY
ParserErrorCode.EXPECTED_BODY
],
'class _s_ {}',
failing: ['functionNonVoid', 'getter']),
TestDescriptor('named', 'class A',
[ParserErrorCode.MISSING_CLASS_BODY], 'class A {}'),
TestDescriptor('named', 'class A', [ParserErrorCode.EXPECTED_BODY],
'class A {}'),
TestDescriptor(
'extend',
'class A extend',
[
ParserErrorCode.EXPECTED_INSTEAD,
ParserErrorCode.EXPECTED_TYPE_NAME,
ParserErrorCode.MISSING_CLASS_BODY
ParserErrorCode.EXPECTED_BODY
],
'class A extend _s_ {}',
expectedErrorsInValidCode: [ParserErrorCode.EXPECTED_INSTEAD],
@ -42,7 +42,7 @@ class ClassDeclarationTest extends PartialCodeTest {
'class A extends',
[
ParserErrorCode.EXPECTED_TYPE_NAME,
ParserErrorCode.MISSING_CLASS_BODY
ParserErrorCode.EXPECTED_BODY
],
'class A extends _s_ {}',
failing: ['functionVoid', 'functionNonVoid', 'getter', 'mixin']),
@ -52,7 +52,7 @@ class ClassDeclarationTest extends PartialCodeTest {
[
ParserErrorCode.EXPECTED_INSTEAD,
ParserErrorCode.EXPECTED_TYPE_NAME,
ParserErrorCode.MISSING_CLASS_BODY
ParserErrorCode.EXPECTED_BODY
],
'class A on _s_ {}',
expectedErrorsInValidCode: [ParserErrorCode.EXPECTED_INSTEAD],
@ -75,7 +75,7 @@ class ClassDeclarationTest extends PartialCodeTest {
'class A extends B with',
[
ParserErrorCode.EXPECTED_TYPE_NAME,
ParserErrorCode.MISSING_CLASS_BODY
ParserErrorCode.EXPECTED_BODY
],
'class A extends B with _s_ {}',
failing: ['functionVoid', 'functionNonVoid', 'getter', 'mixin']),
@ -89,7 +89,7 @@ class ClassDeclarationTest extends PartialCodeTest {
'class A extends B implements',
[
ParserErrorCode.EXPECTED_TYPE_NAME,
ParserErrorCode.MISSING_CLASS_BODY
ParserErrorCode.EXPECTED_BODY
],
'class A extends B implements _s_ {}',
failing: ['functionVoid', 'functionNonVoid', 'getter', 'mixin']),
@ -103,7 +103,7 @@ class ClassDeclarationTest extends PartialCodeTest {
'class A extends B with C implements',
[
ParserErrorCode.EXPECTED_TYPE_NAME,
ParserErrorCode.MISSING_CLASS_BODY
ParserErrorCode.EXPECTED_BODY
],
'class A extends B with C implements _s_ {}',
failing: ['functionVoid', 'functionNonVoid', 'getter', 'mixin']),
@ -117,7 +117,7 @@ class ClassDeclarationTest extends PartialCodeTest {
'class A implements',
[
ParserErrorCode.EXPECTED_TYPE_NAME,
ParserErrorCode.MISSING_CLASS_BODY
ParserErrorCode.EXPECTED_BODY
],
'class A implements _s_ {}',
failing: ['functionVoid', 'functionNonVoid', 'getter', 'mixin']),
@ -131,7 +131,7 @@ class ClassDeclarationTest extends PartialCodeTest {
'class A implements B,',
[
ParserErrorCode.EXPECTED_TYPE_NAME,
ParserErrorCode.MISSING_CLASS_BODY
ParserErrorCode.EXPECTED_BODY
],
'class A implements B, _s_ {}',
failing: ['functionVoid', 'functionNonVoid', 'getter', 'mixin']),

20
pkg/analyzer/test/src/fasta/recovery/partial_code/mixin_declaration_test.dart
View file

@ -20,18 +20,18 @@ class MixinDeclarationTest extends PartialCodeTest {
'mixin',
[
ParserErrorCode.MISSING_IDENTIFIER,
ParserErrorCode.MISSING_CLASS_BODY
ParserErrorCode.EXPECTED_BODY
],
'mixin _s_ {}',
failing: ['functionNonVoid', 'getter']),
TestDescriptor('named', 'mixin A',
[ParserErrorCode.MISSING_CLASS_BODY], 'mixin A {}'),
TestDescriptor('named', 'mixin A', [ParserErrorCode.EXPECTED_BODY],
'mixin A {}'),
TestDescriptor(
'on',
'mixin A on',
[
ParserErrorCode.EXPECTED_TYPE_NAME,
ParserErrorCode.MISSING_CLASS_BODY
ParserErrorCode.EXPECTED_BODY
],
'mixin A on _s_ {}',
failing: ['functionVoid', 'functionNonVoid', 'getter', 'mixin']),
@ -41,7 +41,7 @@ class MixinDeclarationTest extends PartialCodeTest {
[
ParserErrorCode.EXPECTED_INSTEAD,
ParserErrorCode.EXPECTED_TYPE_NAME,
ParserErrorCode.MISSING_CLASS_BODY
ParserErrorCode.EXPECTED_BODY
],
'mixin A extend _s_ {}',
expectedErrorsInValidCode: [ParserErrorCode.EXPECTED_INSTEAD],
@ -52,7 +52,7 @@ class MixinDeclarationTest extends PartialCodeTest {
[
ParserErrorCode.EXPECTED_INSTEAD,
ParserErrorCode.EXPECTED_TYPE_NAME,
ParserErrorCode.MISSING_CLASS_BODY
ParserErrorCode.EXPECTED_BODY
],
'mixin A extends _s_ {}',
expectedErrorsInValidCode: [ParserErrorCode.EXPECTED_INSTEAD],
@ -64,7 +64,7 @@ class MixinDeclarationTest extends PartialCodeTest {
'mixin A on B,',
[
ParserErrorCode.EXPECTED_TYPE_NAME,
ParserErrorCode.MISSING_CLASS_BODY
ParserErrorCode.EXPECTED_BODY
],
'mixin A on B, _s_ {}',
failing: ['functionVoid', 'functionNonVoid', 'getter', 'mixin']),
@ -81,7 +81,7 @@ class MixinDeclarationTest extends PartialCodeTest {
'mixin A on B implements',
[
ParserErrorCode.EXPECTED_TYPE_NAME,
ParserErrorCode.MISSING_CLASS_BODY
ParserErrorCode.EXPECTED_BODY
],
'mixin A on B implements _s_ {}',
failing: ['functionVoid', 'functionNonVoid', 'getter', 'mixin']),
@ -95,7 +95,7 @@ class MixinDeclarationTest extends PartialCodeTest {
'mixin A implements',
[
ParserErrorCode.EXPECTED_TYPE_NAME,
ParserErrorCode.MISSING_CLASS_BODY
ParserErrorCode.EXPECTED_BODY
],
'mixin A implements _s_ {}',
failing: ['functionVoid', 'functionNonVoid', 'getter', 'mixin']),
@ -109,7 +109,7 @@ class MixinDeclarationTest extends PartialCodeTest {
'mixin A implements B,',
[
ParserErrorCode.EXPECTED_TYPE_NAME,
ParserErrorCode.MISSING_CLASS_BODY
ParserErrorCode.EXPECTED_BODY
],
'mixin A implements B, _s_ {}',
failing: ['functionVoid', 'functionNonVoid', 'getter', 'mixin']),