Migrate block 162 to Dart 2.0.

tests/language_2/type_variable_bounds3_test.dart

 // Copyright (c) 2013, 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.
 
 // Test of parameterized types with invalid bounds.
 
 class A<K extends int> {}
 
 class B<X, Y> {

[Bob Nystrom, 2017/08/30 20:02:44]

Is "Y" used for anything? Why is it here?

[eernst, 2017/09/04 17:05:00]

Agreed that `Y` seems to be noise-only here.

Another matter is that every test involving a type argument might be handled
differently when (1) there is only that type argument, (2) there are several
type arguments, and the one we are working with is first/last/in-the-middle,
etc.

We could use code inspection techniques to check that every tool treats every
type argument exactly the same, and in that case we could eliminate all this
noise. But even though it seems to be a reasonable expectation, I don't think we
can maintain such a discipline (we aren't actually going to check after every
commit that every tool still treats type variables identically).

We could also insist that every test must try all cases in this respect, but
that would create a huge number of very similar tests.

Concrete coverage data would be even better, of course, but my conclusion right
now is that we should probably allow for a certain amount of noise of this kind,
rather than trying to eliminate it whenever we see it.

So I'd be happy if we just leave it alone, and if we act in the same way
whenever we see small amounts of "noise" like this.

[jcollins, 2017/09/28 21:16:29]

+1.  I've resisted dropping noise since I noticed when I did so once, a dart2js
test that was crashing magically started working fine.  There are the knowledge
of debuggers gone before us embedded in some of that noise -- the original
author presumably had some cause to do it -- and without concrete coverage data
I'm wary of removing noise too proactively.

   foo(x) {
-    return x is A<X>; // //# 00: dynamic type error, static type warning
+    return x is A<X>; // //# 00: compile-time error
   }
 }
 
 main() {
   var b = new B<double, double>();
   b.foo(new A());
 }