fix #603, support mock objects

lib/src/compiler/code_generator.dart

 // Copyright (c) 2015, 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' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
@@ skipping 527 matching lines @@
       emitExport(export);
     }
   }
 
   @override
   visitAsExpression(AsExpression node) {
     Expression fromExpr = node.expression;
     var from = getStaticType(fromExpr);
     var to = node.type.type;
 
-    var jsFrom = _visit(fromExpr);
+    JS.Expression jsFrom = _visit(fromExpr);
+    if (_inWhitelistCode(node)) return jsFrom;
 
     // Skip the cast if it's not needed.
     if (rules.isSubtypeOf(from, to)) return jsFrom;
 
     // All Dart number types map to a JS double.
     if (_isNumberInJS(from) && _isNumberInJS(to)) {
       // Make sure to check when converting to int.
       if (from != types.intType && to == types.intType) {
         // TODO(jmesserly): fuse this with notNull check.
         return js.call('dart.asInt(#)', jsFrom);
       }
 
       // A no-op in JavaScript.
       return jsFrom;
     }
 
     var type = _emitType(to,
         nameType: options.nameTypeTests || options.hoistTypeTests,
         hoistType: options.hoistTypeTests);
-    if (_inWhitelistCode(node)) return jsFrom;
     if (isReifiedCoercion(node)) {
       return js.call('#._check(#)', [type, jsFrom]);
     } else {
       return js.call('#.as(#)', [type, jsFrom]);
     }
   }
 
   bool isReifiedCoercion(AstNode node) {
     // TODO(sra): Find a better way to recognize reified coercion, since we
     // can't set the isSynthetic attribute.
@@ skipping 725 matching lines @@
         }
         if (m.isStatic) continue;
         for (VariableDeclaration field in m.fields.variables) {
           if (virtualFields.containsKey(field.element)) {
             jsMethods.addAll(_emitVirtualFieldAccessor(field, virtualFields));
           }
         }
       }
     }
 
+    jsMethods.addAll(_implementMockInterfaces(type));
+
     // If the type doesn't have an `iterator`, but claims to implement Iterable,
     // we inject the adaptor method here, as it's less code size to put the
     // helper on a parent class. This pattern is common in the core libraries
     // (e.g. IterableMixin<E> and IterableBase<E>).
     //
     // (We could do this same optimization for any interface with an `iterator`
     // method, but that's more expensive to check for, so it doesn't seem worth
     // it. The above case for an explicit `iterator` method will catch those.)
     if (!hasJsPeer && !hasIterator && _implementsIterable(type)) {
       jsMethods.add(_emitIterable(type));
     }
 
     // Add all of the super helper methods
     jsMethods.addAll(_superHelpers);
     _superHelpers.clear();
 
     return jsMethods.where((m) => m != null).toList(growable: false);
   }
 
+  Iterable<ExecutableElement> _collectMockMethods(InterfaceType type) {
+    var element = type.element;
+    if (!_hasNoSuchMethod(element)) {
+      return [];
+    }
+
+    // Collect all unimplemented members.
+    //
+    // Initially, we track abstract and concrete members separately, then
+    // remove concrete from the abstract set. This is done because abstract
+    // members are allowed to "override" concrete ones in Dart.
+    // (In that case, it will still be treated as a concrete member and can be
+    // called at run time.)
+    var abstractMembers = new Map<String, ExecutableElement>();
+    var concreteMembers = new HashSet<String>();
+
+    void visit(InterfaceType type, bool isAbstract) {
+      if (type == null) return;
+      visit(type.superclass, isAbstract);
+      for (var m in type.mixins) visit(m, isAbstract);
+      for (var i in type.interfaces) visit(i, true);
+
+      var members = <ExecutableElement>[]
+        ..addAll(type.methods)
+        ..addAll(type.accessors);
+      for (var m in members) {
+        if (isAbstract || m.isAbstract) {
+          // Inconsistent signatures are disallowed, even with nSM, so we don't
+          // need to worry too much about which abstract member we save.
+          abstractMembers[m.name] = m;
+        } else {
+          concreteMembers.add(m.name);
+        }
+      }
+    }
+
+    visit(type, false);
+
+    concreteMembers.forEach(abstractMembers.remove);
+    return abstractMembers.values;
+  }
+
+  Iterable<JS.Method> _implementMockInterfaces(InterfaceType type) {

[Leaf, 2016/07/18 23:06:06]

I don't think this is worth worrying about now, but I think this will generate
redundant stubs if you have multiple levels of subclassing won't it?  I don't
imagine that's extremely common though.  Maybe a TODO?

[Jennifer Messerly, 2016/07/19 20:23:54]

Eeeep. Good point. I added a TODO and moar tests

+    return _collectMockMethods(type).map(_implementMockMethod);
+  }
+
+  /// Given a class C that implements method M from interface I, but does not
+  /// declare M, this will generate an implementation that forwards to
+  /// noSuchMethod.
+  ///
+  /// For example:
+  ///
+  ///     class Cat {
+  ///       bool eatFood(String food) => true;
+  ///     }
+  ///     class MockCat implements Cat {
+  ///        noSuchMethod(Invocation invocation) => 3;
+  ///     }
+  ///
+  /// It will generate an `eatFood` that looks like:
+  ///
+  ///     eatFood(food) {
+  ///       return core.bool.as(this.noSuchMethod(
+  ///           new dart.InvocationImpl('eatFood', [food])));
+  ///     }
+  JS.Method _implementMockMethod(ExecutableElement method) {
+    var positionalArgs = <JS.Identifier>[]
+      ..addAll(
+          method.type.normalParameterNames.map((a) => new JS.Identifier(a)))
+      ..addAll(
+          method.type.optionalParameterNames.map((a) => new JS.Identifier(a)));
+
+    var fnArgs = positionalArgs.toList();
+
+    var invocationProps = <JS.Property>[];
+    addProperty(String name, JS.Expression value) {
+      invocationProps.add(new JS.Property(js.string(name), value));
+    }
+
+    if (method.type.namedParameterTypes.isNotEmpty) {
+      fnArgs.add(namedArgumentTemp);
+      addProperty('namedArguments', namedArgumentTemp);
+    }
+
+    if (method is MethodElement) {
+      addProperty('isMethod', js.boolean(true));
+    } else {
+      var property = method as PropertyAccessorElement;
+      if (property.isGetter) {
+        addProperty('isGetter', js.boolean(true));
+      } else if (property.isSetter) {
+        addProperty('isSetter', js.boolean(true));
+      }
+    }
+
+    var fnBody =
+        js.call('this.noSuchMethod(new dart.InvocationImpl(#, #, #))', [
+      _elementMemberName(method),
+      new JS.ArrayInitializer(positionalArgs),
+      new JS.ObjectInitializer(invocationProps)
+    ]);
+
+    if (!method.returnType.isDynamic) {
+      fnBody = js.call('#._check(#)', [_emitType(method.returnType), fnBody]);
+    }
+
+    var fn = new JS.Fun(fnArgs, js.statement('{ return #; }', [fnBody]),
+        typeParams: _emitTypeFormals(method.type.typeFormals));
+
+    // TODO(jmesserly): generic type arguments will get dropped.
+    // We have a similar issue with `dgsend` helpers.
+    return new JS.Method(
+        _elementMemberName(method,
+            useExtension:
+                _extensionTypes.isNativeClass(method.enclosingElement)),
+        _makeGenericFunction(fn),
+        isGetter: method is PropertyAccessorElement && method.isGetter,
+        isSetter: method is PropertyAccessorElement && method.isSetter,
+        isStatic: false);
+  }
+
+  /// Return `true` if the given [classElement] has a noSuchMethod() method
+  /// distinct from the one declared in class Object, as per the Dart Language
+  /// Specification (section 10.4).
+  // TODO(jmesserly): this was taken from error_verifier.dart
+  bool _hasNoSuchMethod(ClassElement classElement) {
+    // TODO(jmesserly): this is slow in Analyzer. It's a linear scan through all
+    // methods, up through the class hierarchy.

[Leaf, 2016/07/18 23:06:07]

ouch.

[Jennifer Messerly, 2016/07/19 20:23:54]

yeah. called multiple times too, just in this visitor! when you consider full
resolution the amount of lookUpMethod is huge. at some point I've wanted to try
radical simplification/optimization experiment but never got around to it :|

+    MethodElement method = classElement.lookUpMethod(
+        FunctionElement.NO_SUCH_METHOD_METHOD_NAME, classElement.library);
+    var definingClass = method?.enclosingElement;
+    return definingClass != null && !definingClass.type.isObject;
+  }
+
   /// This is called whenever a derived class needs to introduce a new field,
   /// shadowing a field or getter/setter pair on its parent.
   ///
   /// This is important because otherwise, trying to read or write the field
   /// would end up calling the getter or setter, and one of those might not even
   /// exist, resulting in a runtime error. Even if they did exist, that's the
   /// wrong behavior if a new field was declared.
   List<JS.Method> _emitVirtualFieldAccessor(VariableDeclaration field,
       Map<FieldElement, JS.TemporaryId> virtualFields) {
     var virtualField = virtualFields[field.element];
@@ skipping 3872 matching lines @@
 }
 
 bool isLibraryPrefix(Expression node) =>
     node is SimpleIdentifier && node.staticElement is PrefixElement;
 
 LibraryElement _getLibrary(AnalysisContext c, String uri) =>
     c.computeLibraryElement(c.sourceFactory.forUri(uri));
 
 bool _isDartRuntime(LibraryElement l) =>
     l.isInSdk && l.source.uri.toString() == 'dart:_runtime';