Resolve type arguments to generic methods.

pkg/compiler/lib/src/resolution/members.dart

 // Copyright (c) 2012, 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.
 
 library dart2js.resolution.members;
 
 import '../common.dart';
 import '../common/names.dart' show Selectors;
 import '../common/resolution.dart' show Resolution;
 import '../compile_time_constants.dart';
@@ skipping 2988 matching lines @@
         // Create [ErroneousElement] for unresolved access.
         ErroneousElement error = reportCannotResolve(node, text);
         return handleUpdate(node, name, new StaticAccess.unresolved(error));
       }
     } else {
       return handleResolvedSendSet(node, name, element);
     }
   }
 
   ResolutionResult visitSend(Send node) {
+    // Resolve type arguments to ensure that these are well-formed types.
+    visit(node.typeArgumentsNode);

[eernst, 2016/11/30 10:39:01]

I basically buy the argument that we can reject "meaningless" programs and
accept "meaningful ones that violate constraints".

I suspect that developers will be confused (they are not likely to see that
distinction spontaneously, and `dart2js` won't help them, it just emits warnings
about certain method invocation type arguments being non-types and accepts
malboundedness silently).

Anyway, I think almost all developers will get their messages from the analyzer,
so we don't really have to worry about all those wrong programs, because they
won't compile them before the analyzer is happy.

So we're good. ;-)

[Johnni Winther, 2016/11/30 11:51:03]

Acknowledged.

     if (node.isOperator) {
       // `a && b`, `a + b`, `-a`, or `a is T`.
       return handleOperatorSend(node);
     } else if (node.receiver != null) {
       // `a.b`.
       return handleQualifiedSend(node);
     } else {
       // `a`.
       return handleUnqualifiedSend(node);
     }
@@ skipping 1726 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(
     DiagnosticReporter reporter, Node node, Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), reporter, node);
 }