Version 3.6.0-261.0.dev

Merge bdddf5e273 into dev

pkg/linter/test/rules/prefer_collection_literals_test.dart

@@ -120,6 +120,140 @@ f() => LinkedHashMap();
     ]);
   }
 
+  test_iterable_emptyConstructor_iterableDeclaration() async {
+    await assertNoDiagnostics(r'''
+void f() {
+  Iterable x = Iterable.empty();
+}
+''');
+  }
+
+  test_linkedHashMap_unnamedConstructor() async {
+    await assertDiagnostics(r'''
+import 'dart:collection';
+void f() {
+  LinkedHashMap();
+}
+''', [
+      lint(39, 15),
+    ]);
+  }
+
+  test_linkedHashMap_unnamedConstructor_linkedHashMapParameterType() async {
+    await assertNoDiagnostics(r'''
+import 'dart:collection';
+void f() {
+  g(LinkedHashMap<int, int>());
+}
+void g(LinkedHashMap<int, int> p) {}
+''');
+  }
+
+  test_linkedHashMap_unnamedConstructor_mapParameterType() async {
+    await assertDiagnostics(r'''
+import 'dart:collection';
+void f() {
+  g(LinkedHashMap<int, int>());
+}
+void g(Map<int, int> p) {}
+''', [
+      lint(41, 25),
+    ]);
+  }
+
+  test_linkedHashSet_fromConstructor() async {
+    await assertDiagnostics(r'''
+import 'dart:collection';
+void f() {
+  LinkedHashSet.from(['foo', 'bar', 'baz']);
+}
+''', [
+      lint(39, 41),
+    ]);
+  }
+
+  test_linkedHashSet_fromConstructor_linkedHashSetDeclaration() async {
+    await assertNoDiagnostics(r'''
+import 'dart:collection';
+void f() {
+  LinkedHashSet<int> x = LinkedHashSet.from([1, 2, 3]);
+}
+''');
+  }
+
+  test_linkedHashSet_fromConstructor_setDeclaration() async {
+    await assertDiagnostics(r'''
+import 'dart:collection';
+void f() {
+  Set<int> x = LinkedHashSet.from([1, 2, 3]);
+}
+''', [
+      lint(52, 29),
+    ]);
+  }
+
+  test_linkedHashSet_ofConstructor() async {
+    await assertDiagnostics(r'''
+import 'dart:collection';
+void f() {
+  LinkedHashSet.of(['foo', 'bar', 'baz']);
+}
+''', [
+      lint(39, 39),
+    ]);
+  }
+
+  test_linkedHashSet_unnamedConstructor() async {
+    await assertDiagnostics(r'''
+import 'dart:collection';
+void f() {
+  LinkedHashSet();
+}
+''', [
+      lint(39, 15),
+    ]);
+  }
+
+  test_linkedHashSet_unnamedConstructor_hashSetParameterType() async {
+    await assertNoDiagnostics(r'''
+import 'dart:collection';
+void f() {
+  g(LinkedHashSet<int>());
+}
+void g(LinkedHashSet<int> p) {}
+''');
+  }
+
+  test_linkedHashSet_unnamedConstructor_linkedHashSetDeclaration() async {
+    await assertNoDiagnostics(r'''
+import 'dart:collection';
+void f() {
+  LinkedHashSet<int> x = LinkedHashSet<int>();
+}
+''');
+  }
+
+  test_linkedHashSet_unnamedConstructor_moreArgs() async {
+    await assertNoDiagnostics(r'''
+import 'dart:collection';
+void f() {
+  LinkedHashSet(equals: (a, b) => false, hashCode: (o) => 13)
+    ..addAll({});
+}
+''');
+  }
+
+  test_linkedHashSet_unnamedConstructor_setDeclaration() async {
+    await assertDiagnostics(r'''
+import 'dart:collection';
+void f() {
+  Set<int> x = LinkedHashSet<int>();
+}
+''', [
+      lint(52, 20),
+    ]);
+  }
+
   /// https://github.com/dart-lang/linter/issues/2985
   test_linkedHashSetParameter_named_type_required() async {
     await assertNoDiagnostics(r'''
@@ -181,6 +315,66 @@ void c() {
     ]);
   }
 
+  test_list_filledConstructor() async {
+    await assertNoDiagnostics(r'''
+void f() {
+  List.filled(5, true);
+}
+''');
+  }
+
+  test_listLiteral() async {
+    await assertNoDiagnostics(r'''
+void f() {
+  [];
+}
+''');
+  }
+
+  test_listLiteral_toSet() async {
+    await assertDiagnostics(r'''
+void f() {
+  ['foo', 'bar', 'baz'].toSet();
+}
+''', [
+      lint(13, 29),
+    ]);
+  }
+
+  test_map_identityConstructor() async {
+    await assertNoDiagnostics(r'''
+void f() {
+  Map.identity();
+}
+''');
+  }
+
+  test_map_unmodifiableConstructor() async {
+    await assertNoDiagnostics(r'''
+void f() {
+  Map.unmodifiable({});
+}
+''');
+  }
+
+  test_map_unnamedConstructor() async {
+    await assertDiagnostics(r'''
+void f() {
+  Map();
+}
+''', [
+      lint(13, 5),
+    ]);
+  }
+
+  test_mapLiteral() async {
+    await assertNoDiagnostics(r'''
+void f() {
+  var x = {};
+}
+''');
+  }
+
   test_returnStatement_async() async {
     await assertNoDiagnostics(r'''
 import 'dart:collection';
@@ -247,6 +441,75 @@ Iterable<LinkedHashSet<int>> f() sync* {
 ''');
   }
 
+  test_set_fromConstructor() async {
+    await assertDiagnostics(r'''
+void f() {
+  Set.from(['foo', 'bar', 'baz']);
+}
+''', [
+      lint(13, 31),
+    ]);
+  }
+
+  test_set_fromConstructor_withTypeArgs() async {
+    await assertDiagnostics(r'''
+void f() {
+  Set<int>.from([]);
+}
+''', [
+      lint(13, 17),
+    ]);
+  }
+
+  test_set_identityConstructor() async {
+    await assertNoDiagnostics(r'''
+void f() {
+  Set.identity();
+}
+''');
+  }
+
+  test_set_ofConstructor() async {
+    await assertDiagnostics(r'''
+void f() {
+  Set.of(['foo', 'bar', 'baz']);
+}
+''', [
+      lint(13, 29),
+    ]);
+  }
+
+  test_set_unnamedConstructor() async {
+    await assertDiagnostics(r'''
+void f() {
+  Set();
+}
+''', [
+      lint(13, 5),
+    ]);
+  }
+
+  test_set_unnamedConstructor_objectParameterType() async {
+    await assertDiagnostics(r'''
+void f() {
+  g(Set());
+}
+void g(Object p) {}
+''', [
+      lint(15, 5),
+    ]);
+  }
+
+  test_set_unnamedContsructor_explicitTypeArgs() async {
+    await assertDiagnostics(r'''
+void f() {
+  Set<int>();
+}
+''', [
+      lint(13, 10),
+    ]);
+  }
+
   test_typedefConstruction() async {
     await assertNoDiagnostics(r'''
 typedef MyMap = Map<int, int>;

pkg/linter/test_data/rules/prefer_collection_literals.dart

@@ -1,89 +0,0 @@
-// Copyright (c) 2017, 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 'dart:collection';
-
-//ignore_for_file: unused_local_variable
-void main() {
-  var mapToLint = new Map(); // LINT
-  var LinkedHashMapToLint = new LinkedHashMap(); // LINT
-
-  var m1 = Map.unmodifiable({}); //OK
-  var m2 = Map.fromIterable([]); //OK
-  var m3 = Map.fromIterables([], []); //OK
-
-  var literalListInsideLiteralList = [[], []]; // OK
-
-  var namedConstructorList = new List.filled(5, true); // OK
-  var namedConstructorMap = new Map.identity(); // OK
-  var namedConstructorLinkedHashMap = new LinkedHashMap.identity(); // OK
-
-  var literalList = []; // OK
-  var literalMap = {}; // OK
-
-  Set s = new Set(); // LINT
-  var s1 = new Set<int>(); // LINT
-  Set<int> s2 = new Set(); // LINT
-  var s3 = new Set.from(['foo', 'bar', 'baz']); // LINT
-  var s4 = new Set.of(['foo', 'bar', 'baz']); // LINT
-
-  var s5 = ['foo', 'bar', 'baz'].toSet(); // LINT
-
-  var s6 = new LinkedHashSet.from(['foo', 'bar', 'baz']); // LINT
-  var s7 = new LinkedHashSet.of(['foo', 'bar', 'baz']); // LINT
-  var s8 = new LinkedHashSet.from(<int>[]); // LINT
-  var s9 = new Set<int>.from([]); // LINT
-
-  var is1 = new Set.identity(); // OK
-  var is2 = new LinkedHashSet.identity(); // OK
-
-  var ss1 = new Set(); // LINT
-  var ss2 = new LinkedHashSet(); // LINT
-  var ss3 = LinkedHashSet.from([]); // LINT
-  var ss4 = LinkedHashSet.of([]); // LINT
-
-  Set<int> ss5 = LinkedHashSet<int>(); // LINT
-  LinkedHashSet<int> ss6 = LinkedHashSet<int>(); // OK
-  Object ss7 = LinkedHashSet<int>(); // LINT
-
-  printObject(Set()); // LINT
-  printSet(Set()); // LINT
-  printObject(LinkedHashSet()); // LINT
-  printSet(LinkedHashSet<int>()); // LINT
-  printIndentedSet(0, LinkedHashSet<int>()); // LINT
-  printHashSet(LinkedHashSet<int>()); // OK
-  printIndentedHashSet(0, LinkedHashSet<int>()); // OK
-
-  Set<int> ss8 = LinkedHashSet.from([1, 2, 3]); // LINT
-  LinkedHashSet<int> ss9 = LinkedHashSet.from([1, 2, 3]); // OK
-
-  Iterable iter = Iterable.empty(); // OK
-  var sss = Set.from(iter); // OK
-
-  LinkedHashSet<String> sss1 = <int, LinkedHashSet<String>>{}
-      .putIfAbsent(3, () => LinkedHashSet<String>()); // OK
-
-  var lhs = LinkedHashSet(equals: (a, b) => false, hashCode: (o) => 13)
-    ..addAll({}); // OK
-
-  LinkedHashMap hashMap = LinkedHashMap(); // OK
-  Object hashMap2 = LinkedHashMap(); // LINT
-
-  printObject(Map()); // LINT
-  printMap(Map()); // LINT
-  printObject(LinkedHashMap()); // LINT
-  printMap(LinkedHashMap<int, int>()); // LINT
-  printHashMap(LinkedHashMap<int, int>()); // OK
-
-  LinkedHashMap<String, String> lhm = <int, LinkedHashMap<String, String>>{}
-      .putIfAbsent(3, () => LinkedHashMap<String, String>()); // OK
-}
-
-void printObject(Object o) => print('$o');
-void printSet(Set<int> ids) => print('$ids!');
-void printIndentedSet(int indent, Set<int> ids) => print('$ids!');
-void printHashSet(LinkedHashSet<int> ids) => printSet(ids);
-void printIndentedHashSet(int indent, LinkedHashSet<int> ids) => printSet(ids);
-void printMap(Map map) => print('$map!');
-void printHashMap(LinkedHashMap map) => printMap(map);

tools/VERSION

@@ -27,5 +27,5 @@ CHANNEL dev
 MAJOR 3
 MINOR 6
 PATCH 0
-PRERELEASE 260
+PRERELEASE 261
 PRERELEASE_PATCH 0