Some preliminary support for quasi-generics

lib/src/checker/resolver.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.
 
 /// Encapsulates how to invoke the analyzer resolver and overrides how it
 /// computes types on expressions to use our restricted set of types.
 library dev_compiler.src.checker.resolver;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 587 matching lines @@
       if (iteratedType != null) {
         element.type = iteratedType;
       }
     }
   }
 
   bool _isSealed(DartType t) {
     return _typeProvider.nonSubtypableTypes.contains(t);
   }
 
+  List<List> _genericList = null;
+
+  DartType _matchGeneric(MethodInvocation node, Element element) {
+    var e = node.methodName.staticElement;
+
+    if (_genericList == null) {
+      var minmax = (DartType tx, DartType ty) => (tx == ty &&
+              (tx == _typeProvider.intType || tx == _typeProvider.doubleType))
+          ? tx
+          : null;
+
+      var map = (DartType tx) => (tx is FunctionType)
+          ? _typeProvider.iterableType.substitute4([tx.returnType])

[vsm, 2015/08/28 15:48:50]

Hmm - rethinking this ...  If my target type (statically) is:

class Foo<T> extends Iterable<T> {
  ...
  List map(Function f) {}
}

and I have:

  target.map((x) => x.toString())

I'll infer Iterable<String> instead of List<dynamic>.

+          : null;
+
+      // TODO(vsm): LUB?
+      var fold = (DartType tx, DartType ty) =>
+          (ty is FunctionType && tx == ty.returnType) ? tx : null;
+
+      // TODO(vsm): Flatten?
+      var then = (DartType tx) =>
+          (tx is FunctionType && !tx.returnType.isDynamic)

[Leaf, 2015/08/28 01:05:38]

Why are you checking for dynamic here, and not elsewhere?

Also, you may need to deal with the fact that these functions can return a
future or a value.  I think this code will get one of the two wrong - I think
the former:

Future<int> f(...) => ...
future.then(f); // This will be inferred as Future<Future<int>>?

EDITED to add: this is probably the point of your TODO?

+              ? _typeProvider.futureType.substitute4([tx.returnType])
+              : null;
+
+      var wait = (DartType tx) {
+        // Iterable<Future<T>> -> Future<List<T>>
+        var futureType = _findIteratedType(tx);
+        if (futureType.element.type != _typeProvider.futureType) return null;
+        var typeArguments = futureType.typeArguments;
+        if (typeArguments.length != 1) return null;
+        var baseType = typeArguments[0];
+        if (baseType.isDynamic) return null;
+        return _typeProvider.futureType.substitute4([
+          _typeProvider.listType.substitute4([baseType])
+        ]);
+      };
+
+      _genericList = [
+        // Top-level methods
+        ['dart:math', 'max', 2, minmax],
+        ['dart:math', 'min', 2, minmax],
+        // Static methods
+        [_typeProvider.futureType, 'wait', 1, wait],
+        // Instance methods
+        [_typeProvider.iterableDynamicType, 'map', 1, map],
+        [_typeProvider.iterableDynamicType, 'fold', 2, fold],
+        [_typeProvider.futureDynamicType, 'then', 1, then],
+      ];
+    }
+
+    var targetType = node.target?.staticType;
+    var arguments = node.argumentList.arguments;
+
+    for (var generic in _genericList) {
+      if (e?.name == generic[1]) {
+        if ((generic[0] is String &&
+                element?.library.source.uri.toString() == generic[0]) ||
+            (targetType == generic[0] ||
+                targetType != null && targetType.isSubtypeOf(generic[0]))) {
+          if (arguments.length == generic[2]) {
+            return Function.apply(
+                generic[3], arguments.map((arg) => arg.staticType).toList());
+          }
+        }
+      }
+    }
+
+    return null;
+  }
+
   @override // to propagate types to identifiers
   visitMethodInvocation(MethodInvocation node) {
     // TODO(jmesserly): we rely on having a staticType propagated to the
     // methodName identifier. This shouldn't be necessary for method calls, so
     // analyzer doesn't do it by default. Conceptually what we're doing here
     // is asking for a tear off. We need this until we can fix #132, and rely
     // on `node.staticElement == null` instead of `rules.isDynamicCall(node)`.
     visitSimpleIdentifier(node.methodName);
 
     super.visitMethodInvocation(node);
@@ skipping 47 matching lines @@
     //
     //     T min<T extends num>(T x, T y);
     //
     // and infer T. In practice, this just means if the type of x and y are
     // both double or both int, we treat that as the return type.
     //
     // The Dart spec has similar treatment for binary operations on numbers.
     //
     // TODO(jmesserly): remove this when we have a fix for
     // https://github.com/dart-lang/dev_compiler/issues/28
-    if (isDartMathMinMax(e)) {
-      var args = node.argumentList.arguments;
-      if (args.length == 2) {
-        var tx = args[0].staticType;
-        var ty = args[1].staticType;
-        if (tx == ty &&
-            (tx == _typeProvider.intType || tx == _typeProvider.doubleType)) {
-          node.staticType = tx;
-        }
-      }
-    }
+    var inferred = _matchGeneric(node, e);
+    if (inferred != null) node.staticType = inferred;
   }
 
   void _inferObjectAccess(
       Expression node, Expression target, SimpleIdentifier id) {
     // Search for Object accesses.
     var name = id.name;
     if (node.staticType.isDynamic &&
         _objectMembers.containsKey(name) &&
         isDynamicTarget(target)) {
       target.staticType = _typeProvider.objectType;
@@ skipping 40 matching lines @@
     }
   }
 
   // Review note: no longer need to override visitFunctionExpression, this is
   // handled by the analyzer internally.
   // TODO(vsm): in visitbinaryExpression: check computeStaticReturnType result?
   // TODO(vsm): in visitFunctionDeclaration: Should we ever use the expression
   // type in a (...) => expr or just the written type?
 
 }