Address feedback, remove type annotations; fork tests for DDC

Author: srawlins

README.md

@@ -190,7 +190,7 @@ Analyzing [lib/cat_test.dart]...
 This code is not Strong mode-compliant. Let's change it to use `typed`:
 
 ```dart
-when(cat.eatFood(typed/*<List<String>>*/(any)))
+when(cat.eatFood(typed(any)))
 ```
 
 ```
@@ -202,19 +202,16 @@ No issues found
 Great! A little ugly, but it works. Here are some more examples:
 
 ```dart
-when(cat.eatFood(typed/*<List<String>>*/(any), typed/*<List<String>>*/(any)))
-    .thenReturn(true);
-when(cat.eatFood(typed/*<List<String>>*/(argThat(contains("fish")))))
-    .thenReturn(true);
+when(cat.eatFood(typed(any), typed(any))).thenReturn(true);
+when(cat.eatFood(typed(argThat(contains("fish"))))).thenReturn(true);
 ```
 
 Named args require one more component: `typed` needs to know what named argument it is
 being passed into:
 
 ```dart
-when(cat.walk(
-    typed/*<List<String>>*/(any),
-    gaits: typed/*<Map<String, String>>*/(any, named: 'gaits'))).thenReturn(true);
+when(cat.walk(typed(any), gaits: typed(any, named: 'gaits')))
+    .thenReturn(true);
 ```
 
 Note the `named` argument. Mockito should fail gracefully if you forget to name a `typed`
@@ -224,10 +221,10 @@ One more note about the `typed` API: you cannot mix `typed` arguments with `null
 arguments:
 
 ```dart
-when(cat.eatFood(null, typed/*<List<String>>*/(any))).thenReturn(true); // Throws!
+when(cat.eatFood(null, typed(any))).thenReturn(true); // Throws!
 when(cat.eatFood(
     argThat(equals(null)),
-    typed/*<List<String>>*/(any))).thenReturn(true); // Works.
+    typed(any))).thenReturn(true); // Works.
 ```
 
 [Strong mode]: https://github.com/dart-lang/dev_compiler/blob/master/STRONG_MODE.md

lib/cats.dart

@@ -0,0 +1,18 @@
+import 'package:test/test.dart';
+import 'mockito.dart';
+
+class Cat {
+  bool eatFood(List<String> foods, [List<String> mixins]) => true;
+  int walk(List<String> places, {Map<String, String> gaits}) => 0;
+}
+
+class MockCat extends Mock implements Cat {}
+
+void fn() {
+  var cat = new MockCat();
+  //when(cat.eatFood()).thenReturn(true);
+  //when(cat.eatFood(any)).thenReturn(true);
+  when(cat.eatFood(typed/*<List<String>>*/(any))).thenReturn(true);
+  when(cat.eatFood(typed/*<List<String>>*/(any), typed/*<List<String>>*/(any)));
+  when(cat.eatFood(typed/*<List<String>>*/(argThat(isEmpty))));
+}

lib/dogs.dart

@@ -0,0 +1,14 @@
+import 'mockito.dart';
+
+class Dog {
+  bool eatFood(String food) => true;
+  bool eatFood2(List<String> foods) => true;
+}
+
+class MockDog extends Mock implements Dog {}
+
+void fn() {
+  var dog = new MockDog();
+  when(dog.eatFood(any)).thenReturn(true);
+  when(dog.eatFood2(any)).thenReturn(true);
+}

lib/src/mock.dart

@@ -63,21 +63,22 @@ class Mock {
 // Return a new [Invocation], reconstituted from [invocation], [_typedArgs],
 // and [_typedNamedArgs].
 Invocation _reconstituteInvocation(Invocation invocation) =>
-  new FakeInvocation(invocation);
+  new _InvocationForTypedArguments(invocation);
 
-/// An Invocation implementation that allows all attributes to be passed into
-/// the constructor.
-class FakeInvocation extends Invocation {
+/// An Invocation implementation that takes arguments from [_typedArgs] and
+/// [_typedNamedArgs].
+class _InvocationForTypedArguments extends Invocation {
   final Symbol memberName;
   final Map<Symbol, dynamic> namedArguments;
   final List<dynamic> positionalArguments;
   final bool isGetter;
   final bool isMethod;
   final bool isSetter;
 
-  factory FakeInvocation(Invocation invocation) {
+  factory _InvocationForTypedArguments(Invocation invocation) {
     if (_typedArgs.isEmpty && _typedNamedArgs.isEmpty) {
-      throw new StateError("FakeInvocation called when no typed calls have been saved.");
+      throw new StateError(
+          "_InvocationForTypedArguments called when no typed calls have been saved.");
     }
 
     // Handle named arguments first, so that we can provide useful errors for
@@ -90,7 +91,7 @@ class FakeInvocation extends Invocation {
     _typedArgs.clear();
     _typedNamedArgs.clear();
 
-    return new FakeInvocation._(
+    return new _InvocationForTypedArguments._(
         invocation.memberName,
         positionalArguments,
         namedArguments,
@@ -99,6 +100,11 @@ class FakeInvocation extends Invocation {
         invocation.isSetter);
   }
 
+  // Reconstitutes the named arguments in an invocation from [_typedNamedArgs].
+  //
+  // The namedArguments in [invocation] which are null should be represented
+  // by a stored value in [_typedNamedArgs]. The null presumably came from
+  // [typed].
   static Map<Symbol,dynamic> _reconstituteNamedArgs(Invocation invocation) {
     var namedArguments = <Symbol, dynamic>{};
     var _typedNamedArgSymbols = _typedNamedArgs.keys.map((name) => new Symbol(name));
@@ -119,22 +125,24 @@ class FakeInvocation extends Invocation {
       }
     });
 
+    // Iterate through the stored named args (stored with [typed]), validate
+    // them, and add them to the return map.
     _typedNamedArgs.forEach((name, arg) {
       Symbol nameSymbol = new Symbol(name);
       if (!invocation.namedArguments.containsKey(nameSymbol)) {
-        // Incorrect usage of [name], something like:
-        // `when(obj.fn(typed(any, named: 'a')))`.
         throw new ArgumentError(
             'A typed argument was declared as named $name, but was not passed '
-            'as an argument named $name.');
+            'as an argument named $name.\n\n'
+            'BAD:  when(obj.fn(typed(any, named: "a")))\n'
+            'GOOD: when(obj.fn(a: typed(any, named: "a")))');
       }
       if (invocation.namedArguments[nameSymbol] != null) {
-        // Incorrect usage of [name], something like:
-        // `when(obj.fn(a: typed(any, named: 'b'), b: "string"))`.
         throw new ArgumentError(
             'A typed argument was declared as named $name, but a different '
             'value (${invocation.namedArguments[nameSymbol]}) was passed as '
-            '$name.');
+            '$name.\n\n'
+            'BAD:  when(obj.fn(b: typed(any, name: "a")))\n'
+            'GOOD: when(obj.fn(b: typed(any, name: "b")))');
       }
       namedArguments[nameSymbol] = arg;
     });
@@ -151,31 +159,32 @@ class FakeInvocation extends Invocation {
           'null arguments are not allowed alongside typed(); use '
           '"typed(eq(null))"');
     }
-    int i = 0;
-    int j = 0;
-    while (i < _typedArgs.length && j < invocation.positionalArguments.length) {
-      var arg = _typedArgs[i];
-      if (invocation.positionalArguments[j] == null) {
+    int typedIndex = 0;
+    int positionalIndex = 0;
+    while (typedIndex < _typedArgs.length &&
+        positionalIndex < invocation.positionalArguments.length) {
+      var arg = _typedArgs[typedIndex];
+      if (invocation.positionalArguments[positionalIndex] == null) {
         // [typed] was used; add the [_ArgMatcher] given to [typed].
         positionalArguments.add(arg);
-        i++;
-        j++;
+        typedIndex++;
+        positionalIndex++;
       } else {
         // [typed] was not used; add the [_ArgMatcher] from [invocation].
-        positionalArguments.add(invocation.positionalArguments[j]);
-        j++;
+        positionalArguments.add(invocation.positionalArguments[positionalIndex]);
+        positionalIndex++;
       }
     }
-    while (j < invocation.positionalArguments.length) {
+    while (positionalIndex < invocation.positionalArguments.length) {
       // Some trailing non-[typed] arguments.
-      positionalArguments.add(invocation.positionalArguments[j]);
-      j++;
+      positionalArguments.add(invocation.positionalArguments[positionalIndex]);
+      positionalIndex++;
     }
 
     return positionalArguments;
   }
 
-  FakeInvocation._(
+  _InvocationForTypedArguments._(
       this.memberName,
       this.positionalArguments,
       this.namedArguments,

test/mockito_test.dart

@@ -11,11 +11,11 @@ class RealClass {
   String methodWithObjArgs(RealClass x) => "Real";
   // "SpecialArgs" here means type-parameterized args. But that makes for a long
   // method name.
-  String methodWithSpecialArgs(
+  String typeParameterizedFn(
       List<int> w, List<int> x, [List<int> y, List<int> z]) => "Real";
   // "SpecialNamedArgs" here means type-parameterized, named args. But that
   // makes for a long method name.
-  String methodWithSpecialNamedArgs(List<int> w, List<int> x, {List<int> y, List<int> z}) =>
+  String typeParameterizedNamedFn(List<int> w, List<int> x, {List<int> y, List<int> z}) =>
       "Real";
   String get getter => "Real";
   void set setter(String arg) {
@@ -219,93 +219,78 @@ void main() {
       expect(mock.methodWithNormalArgs(43), equals("43"));
     });
     test("should mock method with typed arg matchers", () {
-      when(mock.methodWithSpecialArgs(
-          typed/*<List<int>>*/(any), typed/*<List<int>>*/(any)))
+      when(mock.typeParameterizedFn(typed(any), typed(any)))
           .thenReturn("A lot!");
-      expect(mock.methodWithSpecialArgs([42], [43]), equals("A lot!"));
-      expect(mock.methodWithSpecialArgs([43], [44]), equals("A lot!"));
+      expect(mock.typeParameterizedFn([42], [43]), equals("A lot!"));
+      expect(mock.typeParameterizedFn([43], [44]), equals("A lot!"));
     });
     test("should mock method with an optional typed arg matcher", () {
-      when(mock.methodWithSpecialArgs(
-          typed/*<List<int>>*/(any),
-          typed/*<List<int>>*/(any),
-          typed/*<List<int>>*/(any)))
+      when(mock.typeParameterizedFn(typed(any), typed(any), typed(any)))
           .thenReturn("A lot!");
-      expect(mock.methodWithSpecialArgs([42], [43], [44]), equals("A lot!"));
+      expect(mock.typeParameterizedFn([42], [43], [44]), equals("A lot!"));
     });
     test("should mock method with an optional typed arg matcher and an optional real arg", () {
-      when(mock.methodWithSpecialArgs(
-          typed/*<List<int>>*/(any),
-          typed/*<List<int>>*/(any),
-          [44],
-          typed/*<List<int>>*/(any)))
+      when(mock.typeParameterizedFn(typed(any), typed(any), [44], typed(any)))
           .thenReturn("A lot!");
-      expect(mock.methodWithSpecialArgs([42], [43], [44], [45]), equals("A lot!"));
+      expect(mock.typeParameterizedFn([42], [43], [44], [45]), equals("A lot!"));
     });
     test("should mock method with only some typed arg matchers", () {
-      when(mock.methodWithSpecialArgs(
-          typed/*<List<int>>*/(any), [43], typed/*<List<int>>*/(any)))
+      when(mock.typeParameterizedFn(typed(any), [43], typed(any)))
           .thenReturn("A lot!");
-      expect(mock.methodWithSpecialArgs([42], [43], [44]), equals("A lot!"));
-      when(mock.methodWithSpecialArgs(typed/*<List<int>>*/(any), [43]))
+      expect(mock.typeParameterizedFn([42], [43], [44]), equals("A lot!"));
+      when(mock.typeParameterizedFn(typed(any), [43]))
           .thenReturn("A bunch!");
-      expect(mock.methodWithSpecialArgs([42], [43]), equals("A bunch!"));
+      expect(mock.typeParameterizedFn([42], [43]), equals("A bunch!"));
     });
     test("should throw when [typed] used alongside [null].", () {
-      expect(() => when(mock.methodWithSpecialArgs(
-          typed/*<List<int>>*/(any), null, typed/*<List<int>>*/(any))),
+      expect(() => when(mock.typeParameterizedFn(typed(any), null, typed(any))),
           throwsArgumentError);
-      expect(() => when(mock.methodWithSpecialArgs(
-          typed/*<List<int>>*/(any), typed/*<List<int>>*/(any), null)),
+      expect(() => when(mock.typeParameterizedFn(typed(any), typed(any), null)),
           throwsArgumentError);
     });
     test("should mock method when [typed] used alongside matched [null].", () {
-      when(mock.methodWithSpecialArgs(
-          typed/*<List<int>>*/(any), argThat(equals(null)), typed/*<List<int>>*/(any)))
+      when(mock.typeParameterizedFn(
+          typed(any), argThat(equals(null)), typed(any)))
           .thenReturn("A lot!");
-      expect(mock.methodWithSpecialArgs([42], null, [44]), equals("A lot!"));
+      expect(mock.typeParameterizedFn([42], null, [44]), equals("A lot!"));
     });
     test("should mock method with named, typed arg matcher", () {
-      when(mock.methodWithSpecialNamedArgs(
-          typed/*<List<int>>*/(any), [43], y: typed/*<List<int>>*/(any, named: "y")))
+      when(mock.typeParameterizedNamedFn(
+          typed(any), [43], y: typed(any, named: "y")))
           .thenReturn("A lot!");
-      expect(mock.methodWithSpecialNamedArgs([42], [43], y: [44]), equals("A lot!"));
+      expect(mock.typeParameterizedNamedFn([42], [43], y: [44]), equals("A lot!"));
     });
     test("should mock method with named, typed arg matcher and an arg matcher", () {
       when(
-          mock.methodWithSpecialNamedArgs(
-              typed/*<List<int>>*/(any),
-              [43],
-              y: typed/*<List<int>>*/(any, named: "y"),
-              z: argThat(contains(45))))
+          mock.typeParameterizedNamedFn(
+              typed(any), [43],
+              y: typed(any, named: "y"), z: argThat(contains(45))))
           .thenReturn("A lot!");
-      expect(mock.methodWithSpecialNamedArgs([42], [43], y: [44], z: [45]),
+      expect(mock.typeParameterizedNamedFn([42], [43], y: [44], z: [45]),
           equals("A lot!"));
     });
     test("should mock method with named, typed arg matcher and a regular arg", () {
       when(
-          mock.methodWithSpecialNamedArgs(
-              typed/*<List<int>>*/(any),
-              [43],
-              y: typed/*<List<int>>*/(any, named: "y"),
-              z: [45]))
+          mock.typeParameterizedNamedFn(
+              typed(any), [43],
+              y: typed(any, named: "y"), z: [45]))
           .thenReturn("A lot!");
-      expect(mock.methodWithSpecialNamedArgs([42], [43], y: [44], z: [45]),
+      expect(mock.typeParameterizedNamedFn([42], [43], y: [44], z: [45]),
           equals("A lot!"));
     });
     test("should throw when [typed] used as a named arg, without `named:`", () {
-      expect(() => when(mock.methodWithSpecialNamedArgs(
-          typed/*<List<int>>*/(any), [43], y: typed/*<List<int>>*/(any))),
+      expect(() => when(mock.typeParameterizedNamedFn(
+          typed(any), [43], y: typed(any))),
           throwsArgumentError);
     });
     test("should throw when [typed] used as a positional arg, with `named:`", () {
-      expect(() => when(mock.methodWithSpecialNamedArgs(
-          typed/*<List<int>>*/(any), typed/*<List<int>>*/(any, named: "y"))),
+      expect(() => when(mock.typeParameterizedNamedFn(
+          typed(any), typed(any, named: "y"))),
           throwsArgumentError);
     });
     test("should throw when [typed] used as a named arg, with the wrong `named:`", () {
-      expect(() => when(mock.methodWithSpecialNamedArgs(
-          typed/*<List<int>>*/(any), [43], y: typed/*<List<int>>*/(any, named: "z"))),
+      expect(() => when(mock.typeParameterizedNamedFn(
+          typed(any), [43], y: typed(any, named: "z"))),
           throwsArgumentError);
     });
   });
@@ -424,15 +409,14 @@ void main() {
       verify(mock.setter = "A");
     });
     test("should verify method with typed arg matchers", () {
-      mock.methodWithSpecialArgs([42], [43]);
-      verify(mock.methodWithSpecialArgs(
-          typed/*<List<int>>*/(any), typed/*<List<int>>*/(any)));
+      mock.typeParameterizedFn([42], [43]);
+      verify(mock.typeParameterizedFn(typed(any), typed(any)));
     });
     test("should verify method with argument capturer", () {
-      mock.methodWithSpecialArgs([50], [17]);
-      mock.methodWithSpecialArgs([100], [17]);
-      expect(verify(mock.methodWithSpecialArgs(
-          typed/*<List<int>>*/(captureAny), [17])).captured,
+      mock.typeParameterizedFn([50], [17]);
+      mock.typeParameterizedFn([100], [17]);
+      expect(verify(mock.typeParameterizedFn(
+          typed(captureAny), [17])).captured,
           equals([[50], [100]]));
     });
   });