Google Git
Sign in
dart / sdk.git / 1b5df759b842696e32d471acaa3de3368eeedf34 / . / pkg / analyzer / test / src / diagnostics / duplicate_definition_test.dart
blob: 8b2ef95bf6065cb6e4811dd5f7b408ec464e6029 [file] [log] [blame]
// Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
import 'package:analyzer/src/dart/error/syntactic_errors.dart';
import 'package:analyzer/src/error/codes.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
import '../../generated/test_support.dart';
import '../dart/resolution/context_collection_resolution.dart';
main() {
defineReflectiveSuite(() {
defineReflectiveTests(DuplicateDefinitionTest);
defineReflectiveTests(DuplicateDefinitionClassTest);
defineReflectiveTests(DuplicateDefinitionEnumTest);
defineReflectiveTests(DuplicateDefinitionExtensionTest);
defineReflectiveTests(DuplicateDefinitionExtensionTypeTest);
defineReflectiveTests(DuplicateDefinitionMixinTest);
defineReflectiveTests(DuplicateDefinitionUnitTest);
});
}
@reflectiveTest
class DuplicateDefinitionClassTest extends PubPackageResolutionTest {
test_instance_field_field() async {
await assertErrorsInCode(
r'''
class C {
int foo = 0;
int foo = 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
31,
3,
contextMessages: [message(testFile, 16, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_field_field_augment() async {
var a = newFile('$testPackageLibPath/a.dart', r'''
part of 'test.dart';
augment class A {
augment int foo = 42;
}
''');
newFile(testFile.path, r'''
part 'a.dart';
class A {
int foo = 0;
}
''');
await resolveTestFile();
assertNoErrorsInResult();
await resolveFile2(a);
assertNoErrorsInResult();
}
test_instance_field_field_field() async {
await assertErrorsInCode(
r'''
class C {
int foo = 0;
int foo = 0;
int foo = 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
31,
3,
contextMessages: [message(testFile, 16, 3)],
),
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
46,
3,
contextMessages: [message(testFile, 16, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_field_field_inAugmentation() async {
var a = newFile('$testPackageLibPath/a.dart', r'''
part of 'test.dart';
augment class A {
int foo = 42;
}
''');
newFile(testFile.path, r'''
part 'a.dart';
class A {
int foo = 0;
}
''');
await resolveTestFile();
assertNoErrorsInResult();
await resolveFile2(a);
assertErrorsInResult([
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
46,
3,
contextMessages: [message(testFile, 32, 3)],
),
]);
}
test_instance_field_getter() async {
await assertErrorsInCode(
r'''
class C {
int foo = 0;
int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
35,
3,
contextMessages: [message(testFile, 16, 3)],
),
],
);
}
test_instance_field_method() async {
await assertErrorsInCode(
r'''
class C {
int foo = 0;
void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
32,
3,
contextMessages: [message(testFile, 16, 3)],
),
],
);
}
test_instance_fieldFinal_getter() async {
await assertErrorsInCode(
r'''
class C {
final int foo = 0;
int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
41,
3,
contextMessages: [message(testFile, 22, 3)],
),
],
);
}
test_instance_fieldFinal_setter() async {
await assertNoErrorsInCode(r'''
class C {
final int foo = 0;
set foo(int x) {}
}
''');
}
test_instance_fieldLateFinalInitializer_setter() async {
await assertNoErrorsInCode(r'''
class C {
late final int foo = 1;
set foo(_) {}
}
''');
}
test_instance_fieldLateFinalNoInitializer_setter() async {
await assertErrorsInCode(
r'''
class C {
late final int foo;
set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
38,
3,
contextMessages: [message(testFile, 27, 3)],
),
],
);
}
test_instance_getter_getter() async {
await assertErrorsInCode(
r'''
class C {
int get foo => 0;
int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
40,
3,
contextMessages: [message(testFile, 20, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_getter_getter_augment() async {
await assertNoErrorsInCode(r'''
class C {
int get foo => 0;
}
augment class C {
augment int get foo => 0;
}
''');
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_getter_getter_inAugmentation() async {
await assertErrorsInCode(
r'''
class C {
int get foo => 0;
}
augment class C {
int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
61,
3,
contextMessages: [message(testFile, 20, 3)],
),
],
);
}
test_instance_getter_method() async {
await assertErrorsInCode(
r'''
class C {
int get foo => 0;
void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
37,
3,
contextMessages: [message(testFile, 20, 3)],
),
],
);
}
test_instance_getter_setter() async {
await assertNoErrorsInCode(r'''
class C {
int get foo => 0;
set foo(_) {}
}
''');
}
test_instance_method_getter() async {
await assertErrorsInCode(
r'''
class C {
void foo() {}
int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
36,
3,
contextMessages: [message(testFile, 17, 3)],
),
],
);
}
test_instance_method_method() async {
await assertErrorsInCode(
r'''
class C {
void foo() {}
void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
33,
3,
contextMessages: [message(testFile, 17, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_method_method_augment() async {
await assertNoErrorsInCode(r'''
class A {
void foo() {}
}
augment class A {
augment void foo() {}
}
''');
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_method_method_inAugmentation() async {
await assertErrorsInCode(
r'''
class A {
void foo() {}
}
augment class A {
void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
54,
3,
contextMessages: [message(testFile, 17, 3)],
),
],
);
}
test_instance_method_setter() async {
await assertErrorsInCode(
r'''
class C {
void foo() {}
set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
32,
3,
contextMessages: [message(testFile, 17, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_method_setter_inAugmentation() async {
await assertErrorsInCode(
r'''
class A {
void foo() {}
}
augment class A {
set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
53,
3,
contextMessages: [message(testFile, 17, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_operator_operator_augment() async {
await assertNoErrorsInCode(r'''
class A {
int operator +(int _) => 0;
}
augment class A {
augment int operator +(int _) => 0;
}
''');
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_operator_operator_inAugmentation() async {
await assertErrorsInCode(
r'''
class A {
int operator +(int _) => 0;
}
augment class A {
int operator +(int _) => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
76,
1,
contextMessages: [message(testFile, 25, 1)],
),
],
);
}
test_instance_setter_getter() async {
await assertNoErrorsInCode(r'''
class C {
set foo(_) {}
int get foo => 0;
}
''');
}
test_instance_setter_method() async {
await assertErrorsInCode(
r'''
class C {
set foo(_) {}
void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
33,
3,
contextMessages: [message(testFile, 16, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_setter_method_inAugmentation() async {
await assertErrorsInCode(
r'''
class A {
set foo(_) {}
}
augment class A {
void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
54,
3,
contextMessages: [message(testFile, 16, 3)],
),
],
);
}
test_instance_setter_setter() async {
await assertErrorsInCode(
r'''
class C {
void set foo(_) {}
void set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
42,
3,
contextMessages: [message(testFile, 21, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_setter_setter_augment() async {
await assertNoErrorsInCode(r'''
class C {
void set foo(_) {}
}
augment class C {
augment void set foo(_) {}
}
''');
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_setter_setter_inAugmentation() async {
await assertErrorsInCode(
r'''
class C {
void set foo(_) {}
}
augment class C {
void set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
63,
3,
contextMessages: [message(testFile, 21, 3)],
),
],
);
}
test_static_field_field() async {
await assertErrorsInCode(
r'''
class C {
static int foo = 0;
static int foo = 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
45,
3,
contextMessages: [message(testFile, 23, 3)],
),
],
);
}
test_static_field_getter() async {
await assertErrorsInCode(
r'''
class C {
static int foo = 0;
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
49,
3,
contextMessages: [message(testFile, 23, 3)],
),
],
);
}
test_static_field_method() async {
await assertErrorsInCode(
r'''
class C {
static int foo = 0;
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
46,
3,
contextMessages: [message(testFile, 23, 3)],
),
],
);
}
test_static_fieldFinal_getter() async {
await assertErrorsInCode(
r'''
class C {
static final int foo = 0;
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
55,
3,
contextMessages: [message(testFile, 29, 3)],
),
],
);
}
test_static_fieldFinal_setter() async {
await assertNoErrorsInCode(r'''
class C {
static final int foo = 0;
static set foo(int x) {}
}
''');
}
test_static_fieldLateFinalInitializer_setter() async {
await assertNoErrorsInCode(r'''
class C {
static late final int foo = 0;
static set foo(int x) {}
}
''');
}
test_static_fieldLateFinalNoInitializer_setter() async {
await assertErrorsInCode(
r'''
class C {
static late final int foo;
static set foo(int x) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
52,
3,
contextMessages: [message(testFile, 34, 3)],
),
],
);
}
test_static_getter_getter() async {
await assertErrorsInCode(
r'''
class C {
static int get foo => 0;
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
54,
3,
contextMessages: [message(testFile, 27, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_static_getter_getter_augment() async {
await assertNoErrorsInCode(r'''
class A {
static int get foo => 0;
}
augment class A {
augment static int get foo => 0;
}
''');
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_static_getter_getter_inAugmentation() async {
await assertErrorsInCode(
r'''
class A {
static int get foo => 0;
}
augment class A {
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
75,
3,
contextMessages: [message(testFile, 27, 3)],
),
],
);
}
test_static_getter_method() async {
await assertErrorsInCode(
r'''
class C {
static int get foo => 0;
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
51,
3,
contextMessages: [message(testFile, 27, 3)],
),
],
);
}
test_static_getter_setter() async {
await assertNoErrorsInCode(r'''
class C {
static int get foo => 0;
static set foo(_) {}
}
''');
}
test_static_method_getter() async {
await assertErrorsInCode(
r'''
class C {
static void foo() {}
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
50,
3,
contextMessages: [message(testFile, 24, 3)],
),
],
);
}
test_static_method_method() async {
await assertErrorsInCode(
r'''
class C {
static void foo() {}
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
47,
3,
contextMessages: [message(testFile, 24, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_static_method_method_augment() async {
await assertNoErrorsInCode(r'''
class A {
static void foo() {}
}
augment class A {
augment static void foo() {}
}
''');
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_static_method_method_inAugmentation() async {
await assertErrorsInCode(
r'''
class A {
static void foo() {}
}
augment class A {
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
68,
3,
contextMessages: [message(testFile, 24, 3)],
),
],
);
}
test_static_method_setter() async {
await assertErrorsInCode(
r'''
class C {
static void foo() {}
static set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
46,
3,
contextMessages: [message(testFile, 24, 3)],
),
],
);
}
test_static_setter_getter() async {
await assertNoErrorsInCode(r'''
class C {
static set foo(_) {}
static int get foo => 0;
}
''');
}
test_static_setter_method() async {
await assertErrorsInCode(
r'''
class C {
static set foo(_) {}
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
47,
3,
contextMessages: [message(testFile, 23, 3)],
),
],
);
}
test_static_setter_setter() async {
await assertErrorsInCode(
r'''
class C {
static void set foo(_) {}
static void set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
56,
3,
contextMessages: [message(testFile, 28, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_static_setter_setter_augment() async {
await assertNoErrorsInCode(r'''
class A {
static void set foo(_) {}
}
augment class A {
augment static void set foo(_) {}
}
''');
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_static_setter_setter_inAugmentation() async {
await assertErrorsInCode(
r'''
class A {
static void set foo(_) {}
}
augment class A {
static void set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
77,
3,
contextMessages: [message(testFile, 28, 3)],
),
],
);
}
}
@reflectiveTest
class DuplicateDefinitionEnumTest extends PubPackageResolutionTest {
test_constant() async {
await assertErrorsInCode(
r'''
enum E {
foo, foo
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
16,
3,
contextMessages: [message(testFile, 11, 3)],
),
],
);
}
test_instance_field_field() async {
await assertErrorsInCode(
r'''
enum E {
v;
final int foo = 0;
final int foo = 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
47,
3,
contextMessages: [message(testFile, 26, 3)],
),
],
);
}
test_instance_field_getter() async {
await assertErrorsInCode(
r'''
enum E {
v;
final int foo = 0;
int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
45,
3,
contextMessages: [message(testFile, 26, 3)],
),
],
);
}
test_instance_field_method() async {
await assertErrorsInCode(
r'''
enum E {
v;
final int foo = 0;
void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
42,
3,
contextMessages: [message(testFile, 26, 3)],
),
],
);
}
test_instance_fieldFinal_getter() async {
await assertErrorsInCode(
r'''
enum E {
v;
final int foo = 0;
int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
45,
3,
contextMessages: [message(testFile, 26, 3)],
),
],
);
}
test_instance_fieldFinal_setter() async {
await assertNoErrorsInCode(r'''
enum E {
v;
final int foo = 0;
set foo(int x) {}
}
''');
}
test_instance_getter_getter() async {
await assertErrorsInCode(
r'''
enum E {
v;
int get foo => 0;
int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
44,
3,
contextMessages: [message(testFile, 24, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_getter_getter_augment() async {
await assertNoErrorsInCode(r'''
enum E {
v;
int get foo => 0;
}
augment enum E {;
augment int get foo => 0;
}
''');
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_getter_getter_inAugmentation() async {
await assertErrorsInCode(
r'''
enum E {
v;
int get foo => 0;
}
augment enum E {;
int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
65,
3,
contextMessages: [message(testFile, 24, 3)],
),
],
);
}
test_instance_getter_method() async {
await assertErrorsInCode(
r'''
enum E {
v;
int get foo => 0;
void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
41,
3,
contextMessages: [message(testFile, 24, 3)],
),
],
);
}
test_instance_getter_setter() async {
await assertNoErrorsInCode(r'''
enum E {
v;
int get foo => 0;
set foo(_) {}
}
''');
}
test_instance_method_getter() async {
await assertErrorsInCode(
r'''
enum E {
v;
void foo() {}
int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
40,
3,
contextMessages: [message(testFile, 21, 3)],
),
],
);
}
test_instance_method_method() async {
await assertErrorsInCode(
r'''
enum E {
v;
void foo() {}
void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
37,
3,
contextMessages: [message(testFile, 21, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_method_method_augment() async {
await assertNoErrorsInCode(r'''
enum E {
v;
void foo() {}
}
augment enum E {;
augment void foo() {}
}
''');
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_method_method_inAugmentation() async {
await assertErrorsInCode(
r'''
enum E {
v;
void foo() {}
}
augment enum E {;
void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
58,
3,
contextMessages: [message(testFile, 21, 3)],
),
],
);
}
test_instance_method_setter() async {
await assertErrorsInCode(
r'''
enum E {
v;
void foo() {}
set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
36,
3,
contextMessages: [message(testFile, 21, 3)],
),
],
);
}
test_instance_setter_getter() async {
await assertNoErrorsInCode(r'''
enum E {
v;
set foo(_) {}
int get foo => 0;
}
''');
}
test_instance_setter_method() async {
await assertErrorsInCode(
r'''
enum E {
v;
set foo(_) {}
void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
37,
3,
contextMessages: [message(testFile, 20, 3)],
),
],
);
}
test_instance_setter_setter() async {
await assertErrorsInCode(
r'''
enum E {
v;
void set foo(_) {}
void set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
46,
3,
contextMessages: [message(testFile, 25, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_setter_setter_augment() async {
await assertNoErrorsInCode(r'''
enum E {
v;
void set foo(_) {}
}
augment enum E {;
augment void set foo(_) {}
}
''');
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_setter_setter_inAugmentation() async {
await assertErrorsInCode(
r'''
enum E {
v;
void set foo(_) {}
}
augment enum E {;
void set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
67,
3,
contextMessages: [message(testFile, 25, 3)],
),
],
);
}
test_static_constant_field() async {
await assertErrorsInCode(
r'''
enum E {
foo;
static int foo = 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
29,
3,
contextMessages: [message(testFile, 11, 3)],
),
],
);
}
test_static_constant_getter() async {
await assertErrorsInCode(
r'''
enum E {
foo;
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
33,
3,
contextMessages: [message(testFile, 11, 3)],
),
],
);
}
test_static_constant_method() async {
await assertErrorsInCode(
r'''
enum E {
foo;
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
30,
3,
contextMessages: [message(testFile, 11, 3)],
),
],
);
}
test_static_constant_setter() async {
await assertNoErrorsInCode(r'''
enum E {
foo;
static set foo(_) {}
}
''');
}
test_static_field_field() async {
await assertErrorsInCode(
r'''
enum E {
v;
static int foo = 0;
static int foo = 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
49,
3,
contextMessages: [message(testFile, 27, 3)],
),
],
);
}
test_static_field_getter() async {
await assertErrorsInCode(
r'''
enum E {
v;
static int foo = 0;
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
53,
3,
contextMessages: [message(testFile, 27, 3)],
),
],
);
}
test_static_field_method() async {
await assertErrorsInCode(
r'''
enum E {
v;
static int foo = 0;
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
50,
3,
contextMessages: [message(testFile, 27, 3)],
),
],
);
}
test_static_fieldFinal_getter() async {
await assertErrorsInCode(
r'''
enum E {
v;
static final int foo = 0;
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
59,
3,
contextMessages: [message(testFile, 33, 3)],
),
],
);
}
test_static_fieldFinal_setter() async {
await assertNoErrorsInCode(r'''
enum E {
v;
static final int foo = 0;
static set foo(int x) {}
}
''');
}
test_static_getter_getter() async {
await assertErrorsInCode(
r'''
enum E {
v;
static int get foo => 0;
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
58,
3,
contextMessages: [message(testFile, 31, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_static_getter_getter_augment() async {
await assertNoErrorsInCode(r'''
enum E {
v;
static int get foo => 0;
}
augment enum E {;
augment static int get foo => 0;
}
''');
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_static_getter_getter_inAugmentation() async {
await assertErrorsInCode(
r'''
enum E {
v;
static int get foo => 0;
}
augment enum E {;
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
79,
3,
contextMessages: [message(testFile, 31, 3)],
),
],
);
}
test_static_getter_method() async {
await assertErrorsInCode(
r'''
enum E {
v;
static int get foo => 0;
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
55,
3,
contextMessages: [message(testFile, 31, 3)],
),
],
);
}
test_static_getter_setter() async {
await assertNoErrorsInCode(r'''
enum E {
v;
static int get foo => 0;
static set foo(_) {}
}
''');
}
test_static_method_getter() async {
await assertErrorsInCode(
r'''
enum E {
v;
static void foo() {}
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
54,
3,
contextMessages: [message(testFile, 28, 3)],
),
],
);
}
test_static_method_method() async {
await assertErrorsInCode(
r'''
enum E {
v;
static void foo() {}
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
51,
3,
contextMessages: [message(testFile, 28, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_static_method_method_augment() async {
await assertNoErrorsInCode(r'''
enum E {
v;
static void foo() {}
}
augment enum E {;
augment static void foo() {}
}
''');
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_static_method_method_inAugmentation() async {
await assertErrorsInCode(
r'''
enum E {
v;
static void foo() {}
}
augment enum E {;
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
72,
3,
contextMessages: [message(testFile, 28, 3)],
),
],
);
}
test_static_method_setter() async {
await assertErrorsInCode(
r'''
enum E {
v;
static void foo() {}
static set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
50,
3,
contextMessages: [message(testFile, 28, 3)],
),
],
);
}
test_static_setter_getter() async {
await assertNoErrorsInCode(r'''
enum E {
v;
static set foo(_) {}
static int get foo => 0;
}
''');
}
test_static_setter_method() async {
await assertErrorsInCode(
r'''
enum E {
v;
static set foo(_) {}
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
51,
3,
contextMessages: [message(testFile, 27, 3)],
),
],
);
}
test_static_setter_setter() async {
await assertErrorsInCode(
r'''
enum E {
v;
static void set foo(_) {}
static void set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
60,
3,
contextMessages: [message(testFile, 32, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_static_setter_setter_augment() async {
await assertNoErrorsInCode(r'''
enum E {
v;
static void set foo(_) {}
}
augment enum E {;
augment static void set foo(_) {}
}
''');
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_static_setter_setter_inAugmentation() async {
await assertErrorsInCode(
r'''
enum E {
v;
static void set foo(_) {}
}
augment enum E {;
static void set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
81,
3,
contextMessages: [message(testFile, 32, 3)],
),
],
);
}
}
@reflectiveTest
class DuplicateDefinitionExtensionTest extends PubPackageResolutionTest {
test_extendedType_instance() async {
await assertNoErrorsInCode('''
class A {
int get foo => 0;
set foo(_) {}
void bar() {}
}
extension E on A {
int get foo => 0;
set foo(_) {}
void bar() {}
}
''');
}
test_extendedType_static() async {
await assertNoErrorsInCode('''
class A {
static int get foo => 0;
static set foo(_) {}
static void bar() {}
}
extension E on A {
static int get foo => 0;
static set foo(_) {}
static void bar() {}
}
''');
}
test_instance_getter_getter() async {
await assertErrorsInCode(
r'''
class A {}
extension E on A {
int get foo => 0;
int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
60,
3,
contextMessages: [message(testFile, 40, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_getter_getter_augment() async {
await assertNoErrorsInCode(r'''
extension E on int {
int get foo => 0;
}
augment extension E {
augment int get foo => 0;
}
''');
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_getter_getter_inAugmentation() async {
await assertErrorsInCode(
r'''
extension E on int {
int get foo => 0;
}
augment extension E {
int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
76,
3,
contextMessages: [message(testFile, 31, 3)],
),
],
);
}
test_instance_getter_method() async {
await assertErrorsInCode(
r'''
class A {}
extension E on A {
int get foo => 0;
void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
57,
3,
contextMessages: [message(testFile, 40, 3)],
),
],
);
}
test_instance_getter_setter() async {
await assertNoErrorsInCode(r'''
class A {}
extension E on A {
int get foo => 0;
set foo(_) {}
}
''');
}
test_instance_method_getter() async {
await assertErrorsInCode(
r'''
class A {}
extension E on A {
void foo() {}
int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
56,
3,
contextMessages: [message(testFile, 37, 3)],
),
],
);
}
test_instance_method_method() async {
await assertErrorsInCode(
r'''
class A {}
extension E on A {
void foo() {}
void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
53,
3,
contextMessages: [message(testFile, 37, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_method_method_augment() async {
await assertNoErrorsInCode(r'''
extension E on int {
void foo() {}
}
augment extension E {
augment void foo() {}
}
''');
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_method_method_inAugmentation() async {
await assertErrorsInCode(
r'''
extension E on int {
void foo() {}
}
augment extension E {
void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
69,
3,
contextMessages: [message(testFile, 28, 3)],
),
],
);
}
test_instance_method_setter() async {
await assertErrorsInCode(
r'''
class A {}
extension E on A {
void foo() {}
set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
52,
3,
contextMessages: [message(testFile, 37, 3)],
),
],
);
}
test_instance_setter_getter() async {
await assertNoErrorsInCode(r'''
class A {}
extension E on A {
set foo(_) {}
int get foo => 0;
}
''');
}
test_instance_setter_method() async {
await assertErrorsInCode(
r'''
class A {}
extension E on A {
set foo(_) {}
void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
53,
3,
contextMessages: [message(testFile, 36, 3)],
),
],
);
}
test_instance_setter_setter() async {
await assertErrorsInCode(
r'''
class A {}
extension E on A {
void set foo(_) {}
void set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
62,
3,
contextMessages: [message(testFile, 41, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_setter_setter_augment() async {
await assertNoErrorsInCode(r'''
extension E on int {
void set foo(_) {}
}
augment extension E {
augment void set foo(_) {}
}
''');
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_setter_setter_inAugmentation() async {
await assertErrorsInCode(
r'''
extension E on int {
void set foo(_) {}
}
augment extension E {
void set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
78,
3,
contextMessages: [message(testFile, 32, 3)],
),
],
);
}
test_static_field_field() async {
await assertErrorsInCode(
r'''
class A {}
extension E on A {
static int foo = 0;
static int foo = 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
65,
3,
contextMessages: [message(testFile, 43, 3)],
),
],
);
}
test_static_field_getter() async {
await assertErrorsInCode(
r'''
class A {}
extension E on A {
static int foo = 0;
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
69,
3,
contextMessages: [message(testFile, 43, 3)],
),
],
);
}
test_static_field_method() async {
await assertErrorsInCode(
r'''
class A {}
extension E on A {
static int foo = 0;
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
66,
3,
contextMessages: [message(testFile, 43, 3)],
),
],
);
}
test_static_fieldFinal_getter() async {
await assertErrorsInCode(
r'''
class A {}
extension E on A {
static final int foo = 0;
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
75,
3,
contextMessages: [message(testFile, 49, 3)],
),
],
);
}
test_static_fieldFinal_setter() async {
await assertNoErrorsInCode(r'''
class A {}
extension E on A {
static final int foo = 0;
static set foo(int x) {}
}
''');
}
test_static_getter_getter() async {
await assertErrorsInCode(
r'''
class A {}
extension E on A {
static int get foo => 0;
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
74,
3,
contextMessages: [message(testFile, 47, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_static_getter_getter_augment() async {
await assertNoErrorsInCode(r'''
extension E on int {
static int get foo => 0;
}
augment extension E {
augment static int get foo => 0;
}
''');
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_static_getter_getter_inAugmentation() async {
await assertErrorsInCode(
r'''
extension E on int {
static int get foo => 0;
}
augment extension E {
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
90,
3,
contextMessages: [message(testFile, 38, 3)],
),
],
);
}
test_static_getter_method() async {
await assertErrorsInCode(
r'''
class A {}
extension E on A {
static int get foo => 0;
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
71,
3,
contextMessages: [message(testFile, 47, 3)],
),
],
);
}
test_static_getter_setter() async {
await assertNoErrorsInCode(r'''
class A {}
extension E on A {
static int get foo => 0;
static set foo(_) {}
}
''');
}
test_static_method_getter() async {
await assertErrorsInCode(
r'''
class A {}
extension E on A {
static void foo() {}
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
70,
3,
contextMessages: [message(testFile, 44, 3)],
),
],
);
}
test_static_method_method() async {
await assertErrorsInCode(
r'''
class A {}
extension E on A {
static void foo() {}
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
67,
3,
contextMessages: [message(testFile, 44, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_static_method_method_augment() async {
await assertNoErrorsInCode(r'''
extension E on int {
static void foo() {}
}
augment extension E {
augment static void foo() {}
}
''');
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_static_method_method_inAugmentation() async {
await assertErrorsInCode(
r'''
extension E on int {
static void foo() {}
}
augment extension E {
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
83,
3,
contextMessages: [message(testFile, 35, 3)],
),
],
);
}
test_static_method_setter() async {
await assertErrorsInCode(
r'''
class A {}
extension E on A {
static void foo() {}
static set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
66,
3,
contextMessages: [message(testFile, 44, 3)],
),
],
);
}
test_static_setter_getter() async {
await assertNoErrorsInCode(r'''
mixin M {
static set foo(_) {}
static int get foo => 0;
}
''');
}
test_static_setter_method() async {
await assertErrorsInCode(
r'''
class A {}
extension E on A {
static set foo(_) {}
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
67,
3,
contextMessages: [message(testFile, 43, 3)],
),
],
);
}
test_static_setter_setter() async {
await assertErrorsInCode(
r'''
class A {}
extension E on A {
static void set foo(_) {}
static void set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
76,
3,
contextMessages: [message(testFile, 48, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_static_setter_setter_augment() async {
await assertNoErrorsInCode(r'''
extension E on int {
static void set foo(_) {}
}
augment extension E {
augment static void set foo(_) {}
}
''');
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_static_setter_setter_inAugmentation() async {
await assertErrorsInCode(
r'''
extension E on int {
static void set foo(_) {}
}
augment extension E {
static void set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
92,
3,
contextMessages: [message(testFile, 39, 3)],
),
],
);
}
test_unitMembers_extension() async {
await assertErrorsInCode(
'''
class A {}
extension E on A {}
extension E on A {}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
41,
1,
contextMessages: [message(testFile, 21, 1)],
),
],
);
}
}
@reflectiveTest
class DuplicateDefinitionExtensionTypeTest extends PubPackageResolutionTest {
test_instance_getter_getter() async {
await assertErrorsInCode(
r'''
extension type E(int it) {
int get foo => 0;
int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
57,
3,
contextMessages: [message(testFile, 37, 3)],
),
],
);
}
test_instance_getter_method() async {
await assertErrorsInCode(
r'''
extension type E(int it) {
int get foo => 0;
void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
54,
3,
contextMessages: [message(testFile, 37, 3)],
),
],
);
}
test_instance_getter_setter() async {
await assertNoErrorsInCode(r'''
extension type E(int it) {
int get foo => 0;
set foo(_) {}
}
''');
}
test_instance_method_getter() async {
await assertErrorsInCode(
r'''
extension type E(int it) {
void foo() {}
int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
53,
3,
contextMessages: [message(testFile, 34, 3)],
),
],
);
}
test_instance_method_method() async {
await assertErrorsInCode(
r'''
extension type E(int it) {
void foo() {}
void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
50,
3,
contextMessages: [message(testFile, 34, 3)],
),
],
);
}
test_instance_method_setter() async {
await assertErrorsInCode(
r'''
extension type E(int it) {
void foo() {}
set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
49,
3,
contextMessages: [message(testFile, 34, 3)],
),
],
);
}
test_instance_representation_getter() async {
await assertErrorsInCode(
r'''
extension type E(int it) {
int get it => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
37,
2,
contextMessages: [message(testFile, 21, 2)],
),
],
);
}
test_instance_representation_method() async {
await assertErrorsInCode(
r'''
extension type E(int it) {
void it() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
34,
2,
contextMessages: [message(testFile, 21, 2)],
),
],
);
}
test_instance_representation_setter() async {
await assertNoErrorsInCode(r'''
extension type E(int it) {
set it(int _) {}
}
''');
}
test_instance_setter_getter() async {
await assertNoErrorsInCode(r'''
extension type E(int it) {
set foo(_) {}
int get foo => 0;
}
''');
}
test_instance_setter_method() async {
await assertErrorsInCode(
r'''
extension type E(int it) {
set foo(_) {}
void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
50,
3,
contextMessages: [message(testFile, 33, 3)],
),
],
);
}
test_instance_setter_setter() async {
await assertErrorsInCode(
r'''
extension type E(int it) {
void set foo(_) {}
void set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
59,
3,
contextMessages: [message(testFile, 38, 3)],
),
],
);
}
test_static_field_field() async {
await assertErrorsInCode(
r'''
extension type E(int it) {
static int foo = 0;
static int foo = 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
62,
3,
contextMessages: [message(testFile, 40, 3)],
),
],
);
}
test_static_field_getter() async {
await assertErrorsInCode(
r'''
extension type E(int it) {
static int foo = 0;
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
66,
3,
contextMessages: [message(testFile, 40, 3)],
),
],
);
}
test_static_field_method() async {
await assertErrorsInCode(
r'''
extension type E(int it) {
static int foo = 0;
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
63,
3,
contextMessages: [message(testFile, 40, 3)],
),
],
);
}
test_static_fieldFinal_getter() async {
await assertErrorsInCode(
r'''
extension type E(int it) {
static final int foo = 0;
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
72,
3,
contextMessages: [message(testFile, 46, 3)],
),
],
);
}
test_static_fieldFinal_setter() async {
await assertNoErrorsInCode(r'''
extension type E(int it) {
static final int foo = 0;
static set foo(int x) {}
}
''');
}
test_static_getter_getter() async {
await assertErrorsInCode(
r'''
extension type E(int it) {
static int get foo => 0;
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
71,
3,
contextMessages: [message(testFile, 44, 3)],
),
],
);
}
test_static_getter_method() async {
await assertErrorsInCode(
r'''
extension type E(int it) {
static int get foo => 0;
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
68,
3,
contextMessages: [message(testFile, 44, 3)],
),
],
);
}
test_static_getter_setter() async {
await assertNoErrorsInCode(r'''
extension type E(int it) {
static int get foo => 0;
static set foo(_) {}
}
''');
}
test_static_method_getter() async {
await assertErrorsInCode(
r'''
extension type E(int it) {
static void foo() {}
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
67,
3,
contextMessages: [message(testFile, 41, 3)],
),
],
);
}
test_static_method_method() async {
await assertErrorsInCode(
r'''
extension type E(int it) {
static void foo() {}
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
64,
3,
contextMessages: [message(testFile, 41, 3)],
),
],
);
}
test_static_method_setter() async {
await assertErrorsInCode(
r'''
extension type E(int it) {
static void foo() {}
static set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
63,
3,
contextMessages: [message(testFile, 41, 3)],
),
],
);
}
test_static_setter_getter() async {
await assertNoErrorsInCode(r'''
extension type E(int it) {
static set foo(_) {}
static int get foo => 0;
}
''');
}
test_static_setter_method() async {
await assertErrorsInCode(
r'''
extension type E(int it) {
static set foo(_) {}
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
64,
3,
contextMessages: [message(testFile, 40, 3)],
),
],
);
}
test_static_setter_setter() async {
await assertErrorsInCode(
r'''
extension type E(int it) {
static void set foo(_) {}
static void set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
73,
3,
contextMessages: [message(testFile, 45, 3)],
),
],
);
}
test_unitMembers_extensionType() async {
await assertErrorsInCode(
'''
extension type E(int it) {}
extension type E(int it) {}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
43,
1,
contextMessages: [message(testFile, 15, 1)],
),
],
);
}
}
@reflectiveTest
class DuplicateDefinitionMixinTest extends PubPackageResolutionTest {
test_instance_field_field() async {
await assertErrorsInCode(
r'''
mixin M {
int foo = 0;
int foo = 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
31,
3,
contextMessages: [message(testFile, 16, 3)],
),
],
);
}
test_instance_field_getter() async {
await assertErrorsInCode(
r'''
mixin M {
int foo = 0;
int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
35,
3,
contextMessages: [message(testFile, 16, 3)],
),
],
);
}
test_instance_field_method() async {
await assertErrorsInCode(
r'''
mixin M {
int foo = 0;
void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
32,
3,
contextMessages: [message(testFile, 16, 3)],
),
],
);
}
test_instance_fieldFinal_getter() async {
await assertErrorsInCode(
r'''
mixin M {
final int foo = 0;
int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
41,
3,
contextMessages: [message(testFile, 22, 3)],
),
],
);
}
test_instance_fieldFinal_setter() async {
await assertNoErrorsInCode(r'''
mixin M {
final int foo = 0;
set foo(int x) {}
}
''');
}
test_instance_getter_getter() async {
await assertErrorsInCode(
r'''
mixin M {
int get foo => 0;
int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
40,
3,
contextMessages: [message(testFile, 20, 3)],
),
],
);
}
test_instance_getter_method() async {
await assertErrorsInCode(
r'''
mixin M {
int get foo => 0;
void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
37,
3,
contextMessages: [message(testFile, 20, 3)],
),
],
);
}
test_instance_getter_setter() async {
await assertNoErrorsInCode(r'''
mixin M {
int get foo => 0;
set foo(_) {}
}
''');
}
test_instance_method_getter() async {
await assertErrorsInCode(
r'''
mixin M {
void foo() {}
int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
36,
3,
contextMessages: [message(testFile, 17, 3)],
),
],
);
}
test_instance_method_method() async {
await assertErrorsInCode(
r'''
mixin M {
void foo() {}
void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
33,
3,
contextMessages: [message(testFile, 17, 3)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_method_method_augment() async {
var a = newFile('$testPackageLibPath/a.dart', r'''
part of 'test.dart';
augment mixin A {
augment void foo() {}
}
''');
newFile(testFile.path, r'''
part 'a.dart';
mixin A {
void foo() {}
}
''');
await resolveTestFile();
assertNoErrorsInResult();
await resolveFile2(a);
assertNoErrorsInResult();
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_instance_method_method_inAugmentation() async {
var a = newFile('$testPackageLibPath/a.dart', r'''
part of 'test.dart';
augment mixin A {
void foo() {}
}
''');
newFile(testFile.path, r'''
part 'a.dart';
mixin A {
void foo() {}
}
''');
await resolveTestFile();
assertNoErrorsInResult();
await resolveFile2(a);
assertErrorsInResult([
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
47,
3,
contextMessages: [message(testFile, 33, 3)],
),
]);
}
test_instance_method_setter() async {
await assertErrorsInCode(
r'''
mixin M {
void foo() {}
set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
32,
3,
contextMessages: [message(testFile, 17, 3)],
),
],
);
}
test_instance_setter_getter() async {
await assertNoErrorsInCode(r'''
mixin M {
set foo(_) {}
int get foo => 0;
}
''');
}
test_instance_setter_method() async {
await assertErrorsInCode(
r'''
mixin M {
set foo(_) {}
void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
33,
3,
contextMessages: [message(testFile, 16, 3)],
),
],
);
}
test_instance_setter_setter() async {
await assertErrorsInCode(
r'''
mixin M {
void set foo(_) {}
void set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
42,
3,
contextMessages: [message(testFile, 21, 3)],
),
],
);
}
test_static_field_field() async {
await assertErrorsInCode(
r'''
mixin M {
static int foo = 0;
static int foo = 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
45,
3,
contextMessages: [message(testFile, 23, 3)],
),
],
);
}
test_static_field_getter() async {
await assertErrorsInCode(
r'''
mixin M {
static int foo = 0;
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
49,
3,
contextMessages: [message(testFile, 23, 3)],
),
],
);
}
test_static_field_method() async {
await assertErrorsInCode(
r'''
mixin M {
static int foo = 0;
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
46,
3,
contextMessages: [message(testFile, 23, 3)],
),
],
);
}
test_static_fieldFinal_getter() async {
await assertErrorsInCode(
r'''
mixin M {
static final int foo = 0;
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
55,
3,
contextMessages: [message(testFile, 29, 3)],
),
],
);
}
test_static_fieldFinal_setter() async {
await assertNoErrorsInCode(r'''
mixin M {
static final int foo = 0;
static set foo(int x) {}
}
''');
}
test_static_getter_getter() async {
await assertErrorsInCode(
r'''
mixin M {
static int get foo => 0;
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
54,
3,
contextMessages: [message(testFile, 27, 3)],
),
],
);
}
test_static_getter_method() async {
await assertErrorsInCode(
r'''
mixin M {
static int get foo => 0;
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
51,
3,
contextMessages: [message(testFile, 27, 3)],
),
],
);
}
test_static_getter_setter() async {
await assertNoErrorsInCode(r'''
mixin M {
static int get foo => 0;
static set foo(_) {}
}
''');
}
test_static_method_getter() async {
await assertErrorsInCode(
r'''
mixin M {
static void foo() {}
static int get foo => 0;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
50,
3,
contextMessages: [message(testFile, 24, 3)],
),
],
);
}
test_static_method_method() async {
await assertErrorsInCode(
r'''
mixin M {
static void foo() {}
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
47,
3,
contextMessages: [message(testFile, 24, 3)],
),
],
);
}
test_static_method_setter() async {
await assertErrorsInCode(
r'''
mixin M {
static void foo() {}
static set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
46,
3,
contextMessages: [message(testFile, 24, 3)],
),
],
);
}
test_static_setter_getter() async {
await assertNoErrorsInCode(r'''
mixin M {
static set foo(_) {}
static int get foo => 0;
}
''');
}
test_static_setter_method() async {
await assertErrorsInCode(
r'''
mixin M {
static set foo(_) {}
static void foo() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
47,
3,
contextMessages: [message(testFile, 23, 3)],
),
],
);
}
test_static_setter_setter() async {
await assertErrorsInCode(
r'''
mixin M {
static void set foo(_) {}
static void set foo(_) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
56,
3,
contextMessages: [message(testFile, 28, 3)],
),
],
);
}
}
@reflectiveTest
class DuplicateDefinitionTest extends PubPackageResolutionTest {
test_block_localFunction_wildcard() async {
await assertErrorsInCode(
r'''
void f() {
void _() {}
int _(int _) => 42;
String _(int _) => "42";
}
''',
[
error(WarningCode.DEAD_CODE, 13, 11),
error(WarningCode.DEAD_CODE, 27, 19),
error(WarningCode.DEAD_CODE, 49, 24),
],
);
}
test_block_localFunction_wildcard_preWildcards() async {
await assertErrorsInCode(
r'''
// @dart = 3.4
// (pre wildcard-variables)
void f() {
void _() {}
int _(int _) => 42;
String _(int _) => "42";
}
''',
[
error(WarningCode.UNUSED_ELEMENT, 62, 1),
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
75,
1,
contextMessages: [message(testFile, 62, 1)],
),
error(WarningCode.UNUSED_ELEMENT, 75, 1),
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
100,
1,
contextMessages: [message(testFile, 62, 1)],
),
error(WarningCode.UNUSED_ELEMENT, 100, 1),
],
);
}
test_block_localVariable_localVariable() async {
await assertErrorsInCode(
r'''
void f() {
var a = 0;
var a = 1;
}
''',
[
error(WarningCode.UNUSED_LOCAL_VARIABLE, 17, 1),
error(WarningCode.UNUSED_LOCAL_VARIABLE, 30, 1),
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
30,
1,
contextMessages: [message(testFile, 17, 1)],
),
],
);
}
test_block_localVariable_localVariable_wildcard() async {
await assertNoErrorsInCode(r'''
void f() {
var _ = 0;
var _ = 1;
}
''');
}
test_block_localVariable_localVariable_wildcard_preWildcards() async {
await assertErrorsInCode(
r'''
// @dart = 3.4
// (pre wildcard-variables)
void f() {
var _ = 0;
var _ = 1;
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
74,
1,
contextMessages: [message(testFile, 61, 1)],
),
],
);
}
test_block_localVariable_patternVariable() async {
await assertErrorsInCode(
r'''
void f() {
var a = 0;
var (a) = 1;
}
''',
[
error(WarningCode.UNUSED_LOCAL_VARIABLE, 17, 1),
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
31,
1,
contextMessages: [message(testFile, 17, 1)],
),
error(WarningCode.UNUSED_LOCAL_VARIABLE, 31, 1),
],
);
}
test_block_localVariable_patternVariable_wildcard() async {
await assertNoErrorsInCode(r'''
void f() {
var _ = 0;
var (_) = 1;
}
''');
}
test_block_localVariable_patternVariable_wildcard_preWildcards() async {
await assertNoErrorsInCode(r'''
// @dart = 3.4
// (pre wildcard-variables)
void f() {
var _ = 0;
var (_) = 1;
}
''');
}
test_block_patternVariable_localVariable() async {
await assertErrorsInCode(
r'''
void f() {
var (a) = 1;
var a = 0;
}
''',
[
error(WarningCode.UNUSED_LOCAL_VARIABLE, 18, 1),
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
32,
1,
contextMessages: [message(testFile, 18, 1)],
),
error(WarningCode.UNUSED_LOCAL_VARIABLE, 32, 1),
],
);
}
test_block_patternVariable_patternVariable() async {
await assertErrorsInCode(
r'''
void f() {
var (a) = 0;
var (a) = 1;
}
''',
[
error(WarningCode.UNUSED_LOCAL_VARIABLE, 18, 1),
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
33,
1,
contextMessages: [message(testFile, 18, 1)],
),
error(WarningCode.UNUSED_LOCAL_VARIABLE, 33, 1),
],
);
}
test_catch() async {
await assertErrorsInCode(
r'''
main() {
try {} catch (e, e) {}
}''',
[
error(WarningCode.UNUSED_CATCH_STACK, 28, 1),
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
28,
1,
contextMessages: [message(testFile, 25, 1)],
),
],
);
}
test_catch_wildcard() async {
await assertNoErrorsInCode(r'''
f() {
try {} catch (_, _) {}
}''');
}
test_catch_wildcard_preWildCards() async {
await assertErrorsInCode(
r'''
// @dart = 3.4
// (pre wildcard-variables)
f() {
try {} catch (_, _) {}
}''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
69,
1,
contextMessages: [message(testFile, 66, 1)],
),
],
);
}
test_emptyName() async {
// Note: This code has two FunctionElements '() {}' with an empty name; this
// tests that the empty string is not put into the scope (more than once).
await assertErrorsInCode(
r'''
Map _globalMap = {
'a' : () {},
'b' : () {}
};
''',
[error(WarningCode.UNUSED_ELEMENT, 4, 10)],
);
}
test_for_initializers() async {
await assertErrorsInCode(
r'''
f() {
for (int i = 0, i = 0; i < 5;) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
24,
1,
contextMessages: [message(testFile, 17, 1)],
),
error(WarningCode.UNUSED_LOCAL_VARIABLE, 24, 1),
],
);
}
test_for_initializers_wildcard() async {
await assertNoErrorsInCode(r'''
f() {
for (int _ = 0, _ = 0; ;) {}
}
''');
}
test_for_initializers_wildcard_preWildcards() async {
await assertErrorsInCode(
r'''
// @dart = 3.4
// (pre wildcard-variables)
f() {
for (int _ = 0, _ = 0; ;) {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
68,
1,
contextMessages: [message(testFile, 61, 1)],
),
],
);
}
test_getter_single() async {
await assertNoErrorsInCode('''
bool get a => true;
''');
}
test_parameters_constructor_field_first() async {
await assertErrorsInCode(
r'''
class A {
int? a;
A(this.a, int a);
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
36,
1,
contextMessages: [message(testFile, 29, 1)],
),
],
);
}
test_parameters_constructor_field_first_wildcard() async {
await assertErrorsInCode(
r'''
class A {
int? _;
A(this._, int _);
}
''',
[error(WarningCode.UNUSED_FIELD, 17, 1)],
);
}
test_parameters_constructor_field_first_wildcard_preWildcards() async {
await assertErrorsInCode(
r'''
// @dart = 3.4
// (pre wildcard-variables)
class A {
int? _;
A(this._, int _);
}
''',
[
error(WarningCode.UNUSED_FIELD, 61, 1),
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
80,
1,
contextMessages: [message(testFile, 73, 1)],
),
],
);
}
test_parameters_constructor_field_second() async {
await assertErrorsInCode(
r'''
class A {
int? a;
A(int a, this.a);
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
36,
1,
contextMessages: [message(testFile, 28, 1)],
),
],
);
}
test_parameters_constructor_field_second_wildcard() async {
await assertErrorsInCode(
r'''
class A {
int? _;
A(int _, this._);
}
''',
[error(WarningCode.UNUSED_FIELD, 17, 1)],
);
}
test_parameters_constructor_field_second_wildcard_preWildcards() async {
await assertErrorsInCode(
r'''
// @dart = 3.4
// (pre wildcard-variables)
class A {
int? _;
A(int _, this._);
}
''',
[
error(WarningCode.UNUSED_FIELD, 61, 1),
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
80,
1,
contextMessages: [message(testFile, 72, 1)],
),
],
);
}
test_parameters_constructor_super_first_wildcard() async {
await assertErrorsInCode(
r'''
class A {
int? _;
A(this._);
}
class B extends A {
B(super._, super._);
}
''',
[
error(WarningCode.UNUSED_FIELD, 17, 1),
error(
CompileTimeErrorCode
.SUPER_FORMAL_PARAMETER_WITHOUT_ASSOCIATED_POSITIONAL,
74,
1,
),
],
);
}
test_parameters_constructor_super_first_wildcard_preWildcards() async {
await assertErrorsInCode(
r'''
// @dart = 3.4
// (pre wildcard-variables)
class A {
int? _;
A(this._);
}
class B extends A {
B(super._, super._);
}
''',
[
error(WarningCode.UNUSED_FIELD, 61, 1),
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
118,
1,
contextMessages: [message(testFile, 109, 1)],
),
error(
CompileTimeErrorCode
.SUPER_FORMAL_PARAMETER_WITHOUT_ASSOCIATED_POSITIONAL,
118,
1,
),
],
);
}
test_parameters_constructor_this_super_wildcard() async {
await assertErrorsInCode(
r'''
class A {
final int x, y;
A(this.x, [this.y = 0]);
}
class C extends A {
final int _;
C(this._, super._, [super._]);
}
''',
[error(WarningCode.UNUSED_FIELD, 90, 1)],
);
}
test_parameters_functionTypeAlias() async {
await assertErrorsInCode(
r'''
typedef void F(int a, double a);
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
29,
1,
contextMessages: [message(testFile, 19, 1)],
),
],
);
}
test_parameters_functionTypeAlias_wildcard() async {
await assertNoErrorsInCode(r'''
typedef void F(int _, double _);
''');
}
test_parameters_functionTypeAlias_wildcard_preWildcards() async {
await assertErrorsInCode(
r'''
// @dart = 3.4
// (pre wildcard-variables)
typedef void F(int _, double _);
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
73,
1,
contextMessages: [message(testFile, 63, 1)],
),
],
);
}
test_parameters_genericFunction() async {
await assertErrorsInCode(
r'''
typedef F = void Function(int a, double a);
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
40,
1,
contextMessages: [message(testFile, 30, 1)],
),
],
);
}
test_parameters_genericFunction_wildcard() async {
await assertNoErrorsInCode(r'''
typedef F = void Function(int _, double _);
''');
}
test_parameters_genericFunction_wildcard_preWildcards() async {
await assertErrorsInCode(
r'''
// @dart = 3.4
// (pre wildcard-variables)
typedef F = void Function(int _, double _);
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
84,
1,
contextMessages: [message(testFile, 74, 1)],
),
],
);
}
test_parameters_localFunction() async {
await assertErrorsInCode(
r'''
main() {
f(int a, double a) {
};
}
''',
[
error(WarningCode.UNUSED_ELEMENT, 11, 1),
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
27,
1,
contextMessages: [message(testFile, 17, 1)],
),
],
);
}
test_parameters_localFunction_wildcard() async {
await assertErrorsInCode(
r'''
f() {
g(int _, double _) {};
}
''',
[error(WarningCode.UNUSED_ELEMENT, 8, 1)],
);
}
test_parameters_localFunction_wildcard_preWildcards() async {
await assertErrorsInCode(
r'''
// @dart = 3.4
// (pre wildcard-variables)
f() {
g(int _, double _) {};
}
''',
[
error(WarningCode.UNUSED_ELEMENT, 52, 1),
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
68,
1,
contextMessages: [message(testFile, 58, 1)],
),
],
);
}
test_parameters_method() async {
await assertErrorsInCode(
r'''
class A {
m(int a, double a) {
}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
28,
1,
contextMessages: [message(testFile, 18, 1)],
),
],
);
}
test_parameters_method_wildcard() async {
await assertNoErrorsInCode(r'''
class A {
m(int _, double _) {
}
}
''');
}
test_parameters_method_wildcard_preWildcards() async {
await assertErrorsInCode(
r'''
// @dart = 3.4
// (pre wildcard-variables)
class A {
m(int _, double _) {
}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
72,
1,
contextMessages: [message(testFile, 62, 1)],
),
],
);
}
test_parameters_topLevelFunction() async {
await assertErrorsInCode(
r'''
f(int a, double a) {}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
16,
1,
contextMessages: [message(testFile, 6, 1)],
),
],
);
}
test_parameters_topLevelFunction_synthetic() async {
await assertErrorsInCode(
r'''
f(,[]) {}
''',
[
error(ParserErrorCode.MISSING_IDENTIFIER, 2, 1),
error(ParserErrorCode.MISSING_IDENTIFIER, 4, 1),
],
);
}
test_parameters_topLevelFunction_wildcard() async {
await assertNoErrorsInCode(r'''
f(int _, double _) {}
''');
}
test_parameters_topLevelFunction_wildcard_preWildcards() async {
await assertErrorsInCode(
r'''
// @dart = 3.4
// (pre wildcard-variables)
f(int _, double _) {}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
60,
1,
contextMessages: [message(testFile, 50, 1)],
),
],
);
}
test_switchCase_localVariable_localVariable() async {
await assertErrorsInCode(
r'''
// @dart = 2.19
void f() {
switch (0) {
case 0:
var a;
var a;
}
}
''',
[
error(WarningCode.UNUSED_LOCAL_VARIABLE, 64, 1),
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
77,
1,
contextMessages: [message(testFile, 64, 1)],
),
error(WarningCode.UNUSED_LOCAL_VARIABLE, 77, 1),
],
);
}
test_switchDefault_localVariable_localVariable() async {
await assertErrorsInCode(
r'''
void f() {
switch (0) {
default:
var a;
var a;
}
}
''',
[
error(WarningCode.UNUSED_LOCAL_VARIABLE, 49, 1),
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
62,
1,
contextMessages: [message(testFile, 49, 1)],
),
error(WarningCode.UNUSED_LOCAL_VARIABLE, 62, 1),
],
);
}
test_switchDefault_localVariable_localVariable_preWildcards() async {
await assertErrorsInCode(
r'''
// @dart = 3.4
// (pre wildcard-variables)
void f() {
switch (0) {
default:
var _;
var _;
}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
106,
1,
contextMessages: [message(testFile, 93, 1)],
),
],
);
}
test_switchDefault_localVariable_localVariable_wildcard() async {
await assertNoErrorsInCode(r'''
void f() {
switch (0) {
default:
var _;
var _;
}
}
''');
}
test_switchPatternCase_localVariable_localVariable() async {
await assertErrorsInCode(
r'''
void f() {
switch (0) {
case 0:
var a;
var a;
}
}
''',
[
error(WarningCode.UNUSED_LOCAL_VARIABLE, 48, 1),
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
61,
1,
contextMessages: [message(testFile, 48, 1)],
),
error(WarningCode.UNUSED_LOCAL_VARIABLE, 61, 1),
],
);
}
test_switchPatternCase_localVariable_localVariable_wildcard() async {
await assertNoErrorsInCode(r'''
void f() {
switch (0) {
case 0:
var _;
var _;
}
}
''');
}
test_switchPatternCase_localVariable_localVariable_wildcard_preWildCards() async {
await assertErrorsInCode(
r'''
// @dart = 3.4
// (pre wildcard-variables)
void f() {
switch (0) {
case 0:
var _;
var _;
}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
105,
1,
contextMessages: [message(testFile, 92, 1)],
),
],
);
}
test_topLevel_field_field() async {
await assertErrorsInCode(
r'''
var f = 1;
var f = 2;
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
15,
1,
contextMessages: [message(testFile, 4, 1)],
),
],
);
}
test_topLevel_field_getter() async {
await assertErrorsInCode(
r'''
int f = 1;
int get f => 7;
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
19,
1,
contextMessages: [message(testFile, 4, 1)],
),
],
);
}
test_topLevel_field_setter() async {
await assertErrorsInCode(
r'''
int f = 1;
set f(int value) {}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
15,
1,
contextMessages: [message(testFile, 4, 1)],
),
],
);
}
test_topLevel_fieldConst_setter() async {
await assertNoErrorsInCode(r'''
const f = 0;
set f(_) {}
''');
}
test_topLevel_fieldFinal_setter() async {
await assertNoErrorsInCode(r'''
final f = 1;
set f(int value) {}
''');
}
test_topLevel_fieldLateFinalInitializer_setter() async {
await assertNoErrorsInCode(r'''
late final f = 1;
set f(int value) {}
''');
}
test_topLevel_fieldLateFinalNoInitializer_setter() async {
await assertErrorsInCode(
r'''
late final f;
set f(int value) {}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
18,
1,
contextMessages: [message(testFile, 11, 1)],
),
],
);
}
test_topLevel_setter_setter() async {
await assertErrorsInCode(
r'''
set f(int value) {}
set f(int value) {}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
24,
1,
contextMessages: [message(testFile, 4, 1)],
),
],
);
}
test_topLevel_setter_setter_inPart() async {
var a = newFile('$testPackageLibPath/a.dart', r'''
part of 'test.dart';
set f(int value) {}
''');
await assertNoErrorsInCode(r'''
part 'a.dart';
set f(int value) {}
''');
await assertErrorsInFile2(a, [
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
25,
1,
contextMessages: [message(testFile, 19, 1)],
),
]);
}
test_typeParameters_class() async {
await assertErrorsInCode(
r'''
class A<T, T> {}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
11,
1,
contextMessages: [message(testFile, 8, 1)],
),
],
);
}
test_typeParameters_class_wildcard() async {
await assertNoErrorsInCode(r'''
class A<_, _> {}
''');
}
test_typeParameters_class_wildcard_preWildcards() async {
await assertErrorsInCode(
r'''
// @dart = 3.4
// (pre wildcard-variables)
class A<_, _> {}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
55,
1,
contextMessages: [message(testFile, 52, 1)],
),
],
);
}
test_typeParameters_functionTypeAlias() async {
await assertErrorsInCode(
r'''
typedef void F<T, T>();
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
18,
1,
contextMessages: [message(testFile, 15, 1)],
),
],
);
}
test_typeParameters_functionTypeAlias_wildcard() async {
await assertNoErrorsInCode(r'''
typedef void F<_, _>();
''');
}
test_typeParameters_functionTypeAlias_wildcard_preWildcards() async {
await assertErrorsInCode(
r'''
// @dart = 3.4
// (pre wildcard-variables)
typedef void F<_, _>();
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
62,
1,
contextMessages: [message(testFile, 59, 1)],
),
],
);
}
test_typeParameters_genericFunction() async {
await assertErrorsInCode(
r'''
typedef F = void Function<T, T>();
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
29,
1,
contextMessages: [message(testFile, 26, 1)],
),
],
);
}
test_typeParameters_genericFunction_wildcard() async {
await assertNoErrorsInCode(r'''
typedef F = void Function<_, _>();
''');
}
test_typeParameters_genericFunction_wildcard_preWildcards() async {
await assertErrorsInCode(
r'''
// @dart = 3.4
// (pre wildcard-variables)
typedef F = void Function<_, _>();
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
73,
1,
contextMessages: [message(testFile, 70, 1)],
),
],
);
}
test_typeParameters_genericTypedef_functionType() async {
await assertErrorsInCode(
r'''
typedef F<T, T> = void Function();
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
13,
1,
contextMessages: [message(testFile, 10, 1)],
),
],
);
}
test_typeParameters_genericTypedef_functionType_wildcard() async {
await assertNoErrorsInCode(r'''
typedef F<_, _> = void Function();
''');
}
test_typeParameters_genericTypedef_functionType_wildcard_preWildcards() async {
await assertErrorsInCode(
r'''
// @dart = 3.4
// (pre wildcard-variables)
typedef F<_, _> = void Function();
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
57,
1,
contextMessages: [message(testFile, 54, 1)],
),
],
);
}
test_typeParameters_genericTypedef_interfaceType() async {
await assertErrorsInCode(
r'''
typedef F<T, T> = Map;
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
13,
1,
contextMessages: [message(testFile, 10, 1)],
),
],
);
}
test_typeParameters_genericTypedef_interfaceType_wildcard() async {
await assertNoErrorsInCode(r'''
typedef F<_, _> = Map;
''');
}
test_typeParameters_genericTypedef_interfaceType_wildcard_preWildcards() async {
await assertErrorsInCode(
r'''
// @dart = 3.4
// (pre wildcard-variables)
typedef F<_, _> = Map;
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
57,
1,
contextMessages: [message(testFile, 54, 1)],
),
],
);
}
test_typeParameters_method() async {
await assertErrorsInCode(
r'''
class A {
void m<T, T>() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
22,
1,
contextMessages: [message(testFile, 19, 1)],
),
],
);
}
test_typeParameters_method_wildcard() async {
await assertNoErrorsInCode(r'''
class A {
void m<_, _>() {}
}
''');
}
test_typeParameters_method_wildcard_preWildcards() async {
await assertErrorsInCode(
r'''
// @dart = 3.4
// (pre wildcard-variables)
class A {
void m<_, _>() {}
}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
66,
1,
contextMessages: [message(testFile, 63, 1)],
),
],
);
}
test_typeParameters_topLevelFunction() async {
await assertErrorsInCode(
r'''
void f<T, T>() {}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
10,
1,
contextMessages: [message(testFile, 7, 1)],
),
],
);
}
test_typeParameters_topLevelFunction_wildcard() async {
await assertNoErrorsInCode(r'''
void f<_, _>() {}
''');
}
test_typeParameters_topLevelFunction_wildcard_preWildcards() async {
await assertErrorsInCode(
r'''
// @dart = 3.4
// (pre wildcard-variables)
void f<_, _>() {}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
54,
1,
contextMessages: [message(testFile, 51, 1)],
),
],
);
}
}
@reflectiveTest
class DuplicateDefinitionUnitTest extends PubPackageResolutionTest {
test_class() async {
await assertErrorsInCode(
'''
class A {}
class B {}
class A {}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
28,
1,
contextMessages: [message(testFile, 6, 1)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_class_augmentation() async {
var a = newFile('$testPackageLibPath/a.dart', r'''
part of 'test.dart';
augment class A {}
''');
newFile(testFile.path, r'''
part 'a.dart';
class A {}
''');
await resolveTestFile();
assertNoErrorsInResult();
await resolveFile2(a);
assertNoErrorsInResult();
}
test_class_library_part() async {
var lib = newFile('$testPackageLibPath/lib.dart', '''
part 'a.dart';
class A {}
''');
var a = newFile('$testPackageLibPath/a.dart', '''
part of 'lib.dart';
class A {}
''');
await resolveFile(lib);
var aResult = await resolveFile(a);
GatheringDiagnosticListener()
..addAll(aResult.errors)
..assertErrors([
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
27,
1,
contextMessages: [message(lib, 22, 1)],
),
]);
}
test_class_part_part() async {
var lib = newFile('$testPackageLibPath/lib.dart', '''
part 'a.dart';
part 'b.dart';
''');
var a = newFile('$testPackageLibPath/a.dart', '''
part of 'lib.dart';
class A {}
''');
var b = newFile('$testPackageLibPath/b.dart', '''
part of 'lib.dart';
class A {}
''');
await resolveFile(lib);
var aResult = await resolveFile(a);
GatheringDiagnosticListener()
..addAll(aResult.errors)
..assertNoErrors();
var bResult = await resolveFile(b);
GatheringDiagnosticListener()
..addAll(bResult.errors)
..assertErrors([
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
27,
1,
contextMessages: [message(a, 27, 1)],
),
]);
}
test_extension() async {
await assertErrorsInCode(
'''
extension A on int {}
extension B on int {}
extension A on int {}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
54,
1,
contextMessages: [message(testFile, 10, 1)],
),
],
);
}
test_extension_library_part() async {
var lib = newFile('$testPackageLibPath/lib.dart', '''
part 'a.dart';
extension A on int {}
''');
var a = newFile('$testPackageLibPath/a.dart', '''
part of 'lib.dart';
extension A on int {}
''');
await resolveFile(lib);
var aResult = await resolveFile(a);
GatheringDiagnosticListener()
..addAll(aResult.errors)
..assertErrors([
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
31,
1,
contextMessages: [message(lib, 26, 1)],
),
]);
}
test_extensionType() async {
await assertErrorsInCode(
'''
extension type A(int it) {}
extension type B(int it) {}
extension type A(int it) {}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
71,
1,
contextMessages: [message(testFile, 15, 1)],
),
],
);
}
test_extensionType_library_part() async {
var lib = newFile('$testPackageLibPath/lib.dart', '''
part 'a.dart';
extension type A(int it) {}
''');
var a = newFile('$testPackageLibPath/a.dart', '''
part of 'lib.dart';
extension type A(int it) {}
''');
await resolveFile(lib);
var aResult = await resolveFile(a);
GatheringDiagnosticListener()
..addAll(aResult.errors)
..assertErrors([
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
36,
1,
contextMessages: [message(lib, 31, 1)],
),
]);
}
test_mixin() async {
await assertErrorsInCode(
'''
mixin A {}
mixin B {}
mixin A {}
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
28,
1,
contextMessages: [message(testFile, 6, 1)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_mixin_augmentation() async {
var a = newFile('$testPackageLibPath/a.dart', r'''
part of 'test.dart';
augment mixin A {}
''');
newFile(testFile.path, r'''
part 'a.dart';
mixin A {}
''');
await resolveTestFile();
assertNoErrorsInResult();
await resolveFile2(a);
assertNoErrorsInResult();
}
test_mixin_library_part() async {
var lib = newFile('$testPackageLibPath/lib.dart', '''
part 'a.dart';
mixin A {}
''');
var a = newFile('$testPackageLibPath/a.dart', '''
part of 'lib.dart';
mixin A {}
''');
await resolveFile(lib);
var aResult = await resolveFile(a);
GatheringDiagnosticListener()
..addAll(aResult.errors)
..assertErrors([
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
27,
1,
contextMessages: [message(lib, 22, 1)],
),
]);
}
test_typedef_interfaceType() async {
await assertErrorsInCode(
'''
typedef A = List<int>;
typedef A = List<int>;
''',
[
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
31,
1,
contextMessages: [message(testFile, 8, 1)],
),
],
);
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_variable_variable_augment() async {
var a = newFile('$testPackageLibPath/a.dart', r'''
part of 'test.dart';
augment int foo = 42;
''');
newFile(testFile.path, r'''
part 'a.dart';
int foo = 0;
''');
await resolveTestFile();
assertNoErrorsInResult();
await resolveFile2(a);
assertNoErrorsInResult();
}
@SkippedTest() // TODO(scheglov): implement augmentation
test_variable_variable_inAugmentation() async {
var a = newFile('$testPackageLibPath/a.dart', r'''
part of 'test.dart';
int foo = 42;
''');
newFile(testFile.path, r'''
part 'a.dart';
int foo = 0;
''');
await resolveTestFile();
assertNoErrorsInResult();
await resolveFile2(a);
assertErrorsInResult([
error(
CompileTimeErrorCode.DUPLICATE_DEFINITION,
26,
3,
contextMessages: [message(testFile, 20, 3)],
),
]);
}
}