Fix the more specific relation.

tests/compiler/dart2js/subtype_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.
 
 library subtype_test;
 
 import 'package:expect/expect.dart';
 import "package:async_helper/async_helper.dart";
 import 'type_test_helper.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/dart_types.dart';
@@ skipping 49 matching lines @@
     DartType Object_ = env['Object'];
     DartType num_ = env['num'];
     DartType int_ = env['int'];
     DartType String_ = env['String'];
     DartType dynamic_ = env['dynamic'];
 
     expect(true, Object_, Object_);
     expect(true, num_, Object_);
     expect(true, int_, Object_);
     expect(true, String_, Object_);
-    expect(true, dynamic_, Object_);
+    expect(true, dynamic_, Object_, expectMoreSpecific: false);
 
     expect(false, Object_, num_);
     expect(true, num_, num_);
     expect(true, int_, num_);
     expect(false, String_, num_);
-    expect(true, dynamic_, num_);
+    expect(true, dynamic_, num_, expectMoreSpecific: false);
 
     expect(false, Object_, int_);
     expect(false, num_, int_);
     expect(true, int_, int_);
     expect(false, String_, int_);
-    expect(true, dynamic_, int_);
+    expect(true, dynamic_, int_, expectMoreSpecific: false);
 
     expect(false, Object_, String_);
     expect(false, num_, String_);
     expect(false, int_, String_);
     expect(true, String_, String_);
-    expect(true, dynamic_, String_);
+    expect(true, dynamic_, String_, expectMoreSpecific: false);
 
-    expect(true, Object_, dynamic_, expectMoreSpecific: false);
-    expect(true, num_, dynamic_, expectMoreSpecific: false);
-    expect(true, int_, dynamic_, expectMoreSpecific: false);
-    expect(true, String_, dynamic_, expectMoreSpecific: false);
+    expect(true, Object_, dynamic_);
+    expect(true, num_, dynamic_);
+    expect(true, int_, dynamic_);
+    expect(true, String_, dynamic_);
     expect(true, dynamic_, dynamic_);
 
     DartType A_Object = instantiate(A, [Object_]);
     DartType A_num = instantiate(A, [num_]);
     DartType A_int = instantiate(A, [int_]);
     DartType A_String = instantiate(A, [String_]);
     DartType A_dynamic = instantiate(A, [dynamic_]);
 
     expect(true, A_Object, Object_);
     expect(false, A_Object, num_);
     expect(false, A_Object, int_);
     expect(false, A_Object, String_);
-    expect(true, A_Object, dynamic_, expectMoreSpecific: false);
+    expect(true, A_Object, dynamic_);
 
     expect(true, A_Object, A_Object);
     expect(true, A_num, A_Object);
     expect(true, A_int, A_Object);
     expect(true, A_String, A_Object);
-    expect(true, A_dynamic, A_Object);
+    expect(true, A_dynamic, A_Object, expectMoreSpecific: false);
 
     expect(false, A_Object, A_num);
     expect(true, A_num, A_num);
     expect(true, A_int, A_num);
     expect(false, A_String, A_num);
-    expect(true, A_dynamic, A_num);
+    expect(true, A_dynamic, A_num, expectMoreSpecific: false);
 
     expect(false, A_Object, A_int);
     expect(false, A_num, A_int);
     expect(true, A_int, A_int);
     expect(false, A_String, A_int);
-    expect(true, A_dynamic, A_int);
+    expect(true, A_dynamic, A_int, expectMoreSpecific: false);
 
     expect(false, A_Object, A_String);
     expect(false, A_num, A_String);
     expect(false, A_int, A_String);
     expect(true, A_String, A_String);
-    expect(true, A_dynamic, A_String);
+    expect(true, A_dynamic, A_String, expectMoreSpecific: false);
 
-    expect(true, A_Object, A_dynamic, expectMoreSpecific: false);
-    expect(true, A_num, A_dynamic, expectMoreSpecific: false);
-    expect(true, A_int, A_dynamic, expectMoreSpecific: false);
-    expect(true, A_String, A_dynamic, expectMoreSpecific: false);
+    expect(true, A_Object, A_dynamic);
+    expect(true, A_num, A_dynamic);
+    expect(true, A_int, A_dynamic);
+    expect(true, A_String, A_dynamic);
     expect(true, A_dynamic, A_dynamic);
 
     DartType B_Object_Object = instantiate(B, [Object_, Object_]);
     DartType B_num_num = instantiate(B, [num_, num_]);
     DartType B_int_num = instantiate(B, [int_, num_]);
     DartType B_dynamic_dynamic = instantiate(B, [dynamic_, dynamic_]);
     DartType B_String_dynamic = instantiate(B, [String_, dynamic_]);
 
     expect(true, B_Object_Object, Object_);
     expect(true, B_Object_Object, A_Object);
     expect(false, B_Object_Object, A_num);
     expect(false, B_Object_Object, A_int);
     expect(false, B_Object_Object, A_String);
-    expect(true, B_Object_Object, A_dynamic, expectMoreSpecific: false);
+    expect(true, B_Object_Object, A_dynamic);
 
     expect(true, B_num_num, Object_);
     expect(true, B_num_num, A_Object);
     expect(true, B_num_num, A_num);
     expect(false, B_num_num, A_int);
     expect(false, B_num_num, A_String);
-    expect(true, B_num_num, A_dynamic, expectMoreSpecific: false);
+    expect(true, B_num_num, A_dynamic);
 
     expect(true, B_int_num, Object_);
     expect(true, B_int_num, A_Object);
     expect(true, B_int_num, A_num);
     expect(true, B_int_num, A_int);
     expect(false, B_int_num, A_String);
-    expect(true, B_int_num, A_dynamic, expectMoreSpecific: false);
+    expect(true, B_int_num, A_dynamic);
 
     expect(true, B_dynamic_dynamic, Object_);
-    expect(true, B_dynamic_dynamic, A_Object);
-    expect(true, B_dynamic_dynamic, A_num);
-    expect(true, B_dynamic_dynamic, A_int);
-    expect(true, B_dynamic_dynamic, A_String);
+    expect(true, B_dynamic_dynamic, A_Object, expectMoreSpecific: false);
+    expect(true, B_dynamic_dynamic, A_num, expectMoreSpecific: false);
+    expect(true, B_dynamic_dynamic, A_int, expectMoreSpecific: false);
+    expect(true, B_dynamic_dynamic, A_String, expectMoreSpecific: false);
     expect(true, B_dynamic_dynamic, A_dynamic);
 
     expect(true, B_String_dynamic, Object_);
     expect(true, B_String_dynamic, A_Object);
     expect(false, B_String_dynamic, A_num);
     expect(false, B_String_dynamic, A_int);
     expect(true, B_String_dynamic, A_String);
-    expect(true, B_String_dynamic, A_dynamic, expectMoreSpecific: false);
+    expect(true, B_String_dynamic, A_dynamic);
 
     expect(true, B_Object_Object, B_Object_Object);
     expect(true, B_num_num, B_Object_Object);
     expect(true, B_int_num, B_Object_Object);
-    expect(true, B_dynamic_dynamic, B_Object_Object);
-    expect(true, B_String_dynamic, B_Object_Object);
+    expect(true, B_dynamic_dynamic, B_Object_Object, expectMoreSpecific: false);
+    expect(true, B_String_dynamic, B_Object_Object, expectMoreSpecific: false);
 
     expect(false, B_Object_Object, B_num_num);
     expect(true, B_num_num, B_num_num);
     expect(true, B_int_num, B_num_num);
-    expect(true, B_dynamic_dynamic, B_num_num);
+    expect(true, B_dynamic_dynamic, B_num_num, expectMoreSpecific: false);
     expect(false, B_String_dynamic, B_num_num);
 
     expect(false, B_Object_Object, B_int_num);
     expect(false, B_num_num, B_int_num);
     expect(true, B_int_num, B_int_num);
-    expect(true, B_dynamic_dynamic, B_int_num);
+    expect(true, B_dynamic_dynamic, B_int_num, expectMoreSpecific: false);
     expect(false, B_String_dynamic, B_int_num);
 
-    expect(true, B_Object_Object, B_dynamic_dynamic, expectMoreSpecific: false);
-    expect(true, B_num_num, B_dynamic_dynamic, expectMoreSpecific: false);
-    expect(true, B_int_num, B_dynamic_dynamic, expectMoreSpecific: false);
+    expect(true, B_Object_Object, B_dynamic_dynamic);
+    expect(true, B_num_num, B_dynamic_dynamic);
+    expect(true, B_int_num, B_dynamic_dynamic);
     expect(true, B_dynamic_dynamic, B_dynamic_dynamic);
-    expect(true, B_String_dynamic, B_dynamic_dynamic,
-           expectMoreSpecific: false);
+    expect(true, B_String_dynamic, B_dynamic_dynamic);
 
     expect(false, B_Object_Object, B_String_dynamic);
     expect(false, B_num_num, B_String_dynamic);
     expect(false, B_int_num, B_String_dynamic);
-    expect(true, B_dynamic_dynamic, B_String_dynamic);
+    expect(true, B_dynamic_dynamic, B_String_dynamic,
+           expectMoreSpecific: false);
     expect(true, B_String_dynamic, B_String_dynamic);
 
     DartType C_Object_Object = instantiate(C, [Object_, Object_]);
     DartType C_num_num = instantiate(C, [num_, num_]);
     DartType C_int_String = instantiate(C, [int_, String_]);
     DartType C_dynamic_dynamic = instantiate(C, [dynamic_, dynamic_]);
 
     expect(true, C_Object_Object, B_Object_Object);
     expect(false, C_Object_Object, B_num_num);
     expect(false, C_Object_Object, B_int_num);
-    expect(true, C_Object_Object, B_dynamic_dynamic, expectMoreSpecific: false);
+    expect(true, C_Object_Object, B_dynamic_dynamic);
     expect(false, C_Object_Object, B_String_dynamic);
 
     expect(true, C_num_num, B_Object_Object);
     expect(true, C_num_num, B_num_num);
     expect(false, C_num_num, B_int_num);
-    expect(true, C_num_num, B_dynamic_dynamic, expectMoreSpecific: false);
+    expect(true, C_num_num, B_dynamic_dynamic);
     expect(false, C_num_num, B_String_dynamic);
 
     expect(true, C_int_String, B_Object_Object);
     expect(false, C_int_String, B_num_num);
     expect(false, C_int_String, B_int_num);
-    expect(true, C_int_String, B_dynamic_dynamic, expectMoreSpecific: false);
-    expect(true, C_int_String, B_String_dynamic, expectMoreSpecific: false);
+    expect(true, C_int_String, B_dynamic_dynamic);
+    expect(true, C_int_String, B_String_dynamic);
 
-    expect(true, C_dynamic_dynamic, B_Object_Object);
-    expect(true, C_dynamic_dynamic, B_num_num);
-    expect(true, C_dynamic_dynamic, B_int_num);
+    expect(true, C_dynamic_dynamic, B_Object_Object, expectMoreSpecific: false);
+    expect(true, C_dynamic_dynamic, B_num_num, expectMoreSpecific: false);
+    expect(true, C_dynamic_dynamic, B_int_num, expectMoreSpecific: false);
     expect(true, C_dynamic_dynamic, B_dynamic_dynamic);
-    expect(true, C_dynamic_dynamic, B_String_dynamic);
+    expect(true, C_dynamic_dynamic, B_String_dynamic,
+           expectMoreSpecific: false);
 
     expect(false, C_int_String, A_int);
     expect(true, C_int_String, A_String);
     // TODO(johnniwinther): Inheritance with different type arguments is
     // currently not supported by the implementation.
     //expect(true, C_int_String, instantiate(A, [A_int]));
     expect(false, C_int_String, instantiate(A, [A_String]));
   }));
 }
 
@@ skipping 331 matching lines @@
     DartType num_ = env['num'];
     DartType int_ = env['int'];
     DartType String_ = env['String'];
     DartType dynamic_ = env['dynamic'];
 
     // class A<T> {}
     expect(true, A_T, Object_);
     expect(false, A_T, num_);
     expect(false, A_T, int_);
     expect(false, A_T, String_);
-    expect(true, A_T, dynamic_, expectMoreSpecific: false);
+    expect(true, A_T, dynamic_);
     expect(true, A_T, A_T);
     expect(false, A_T, B_T);
 
     // class B<T extends Object> {}
     expect(true, B_T, Object_);
     expect(false, B_T, num_);
     expect(false, B_T, int_);
     expect(false, B_T, String_);
-    expect(true, B_T, dynamic_, expectMoreSpecific: false);
+    expect(true, B_T, dynamic_);
     expect(true, B_T, B_T);
     expect(false, B_T, A_T);
 
     // class C<T extends num> {}
     expect(true, C_T, Object_);
     expect(true, C_T, num_);
     expect(false, C_T, int_);
     expect(false, C_T, String_);
-    expect(true, C_T, dynamic_, expectMoreSpecific: false);
+    expect(true, C_T, dynamic_);
     expect(true, C_T, C_T);
     expect(false, C_T, A_T);
 
     // class D<T extends int> {}
     expect(true, D_T, Object_);
     expect(true, D_T, num_);
     expect(true, D_T, int_);
     expect(false, D_T, String_);
-    expect(true, D_T, dynamic_, expectMoreSpecific: false);
+    expect(true, D_T, dynamic_);
     expect(true, D_T, D_T);
     expect(false, D_T, A_T);
 
     // class E<T extends S, S extends num> {}
     expect(true, E_T, Object_);
     expect(true, E_T, num_);
     expect(false, E_T, int_);
     expect(false, E_T, String_);
-    expect(true, E_T, dynamic_, expectMoreSpecific: false);
+    expect(true, E_T, dynamic_);
     expect(true, E_T, E_T);
     expect(true, E_T, E_S);
     expect(false, E_T, A_T);
 
     expect(true, E_S, Object_);
     expect(true, E_S, num_);
     expect(false, E_S, int_);
     expect(false, E_S, String_);
-    expect(true, E_S, dynamic_, expectMoreSpecific: false);
+    expect(true, E_S, dynamic_);
     expect(false, E_S, E_T);
     expect(true, E_S, E_S);
     expect(false, E_S, A_T);
 
     // class F<T extends num, S extends T> {}
     expect(true, F_T, Object_);
     expect(true, F_T, num_);
     expect(false, F_T, int_);
     expect(false, F_T, String_);
-    expect(true, F_T, dynamic_, expectMoreSpecific: false);
+    expect(true, F_T, dynamic_);
     expect(false, F_T, F_S);
     expect(true, F_T, F_T);
     expect(false, F_T, A_T);
 
     expect(true, F_S, Object_);
     expect(true, F_S, num_);
     expect(false, F_S, int_);
     expect(false, F_S, String_);
-    expect(true, F_S, dynamic_, expectMoreSpecific: false);
+    expect(true, F_S, dynamic_);
     expect(true, F_S, F_S);
     expect(true, F_S, F_T);
     expect(false, F_S, A_T);
 
     // class G<T extends T> {}
     expect(true, G_T, Object_);
     expect(false, G_T, num_);
     expect(false, G_T, int_);
     expect(false, G_T, String_);
-    expect(true, G_T, dynamic_, expectMoreSpecific: false);
+    expect(true, G_T, dynamic_);
     expect(true, G_T, G_T);
     expect(false, G_T, A_T);
 
     // class H<T extends S, S extends T> {}
     expect(true, H_T, Object_);
     expect(false, H_T, num_);
     expect(false, H_T, int_);
     expect(false, H_T, String_);
-    expect(true, H_T, dynamic_, expectMoreSpecific: false);
+    expect(true, H_T, dynamic_);
     expect(true, H_T, H_T);
     expect(true, H_T, H_S);
     expect(false, H_T, A_T);
 
     expect(true, H_S, Object_);
     expect(false, H_S, num_);
     expect(false, H_S, int_);
     expect(false, H_S, String_);
-    expect(true, H_S, dynamic_, expectMoreSpecific: false);
+    expect(true, H_S, dynamic_);
     expect(true, H_S, H_T);
     expect(true, H_S, H_S);
     expect(false, H_S, A_T);
 
     // class I<T extends S, S extends U, U extends T> {}
     expect(true, I_T, Object_);
     expect(false, I_T, num_);
     expect(false, I_T, int_);
     expect(false, I_T, String_);
-    expect(true, I_T, dynamic_, expectMoreSpecific: false);
+    expect(true, I_T, dynamic_);
     expect(true, I_T, I_T);
     expect(true, I_T, I_S);
     expect(true, I_T, I_U);
     expect(false, I_T, A_T);
 
     expect(true, I_S, Object_);
     expect(false, I_S, num_);
     expect(false, I_S, int_);
     expect(false, I_S, String_);
-    expect(true, I_S, dynamic_, expectMoreSpecific: false);
+    expect(true, I_S, dynamic_);
     expect(true, I_S, I_T);
     expect(true, I_S, I_S);
     expect(true, I_S, I_U);
     expect(false, I_S, A_T);
 
     expect(true, I_U, Object_);
     expect(false, I_U, num_);
     expect(false, I_U, int_);
     expect(false, I_U, String_);
-    expect(true, I_U, dynamic_, expectMoreSpecific: false);
+    expect(true, I_U, dynamic_);
     expect(true, I_U, I_T);
     expect(true, I_U, I_S);
     expect(true, I_U, I_U);
     expect(false, I_U, A_T);
 
     // class J<T extends S, S extends U, U extends S> {}
     expect(true, J_T, Object_);
     expect(false, J_T, num_);
     expect(false, J_T, int_);
     expect(false, J_T, String_);
-    expect(true, J_T, dynamic_, expectMoreSpecific: false);
+    expect(true, J_T, dynamic_);
     expect(true, J_T, J_T);
     expect(true, J_T, J_S);
     expect(true, J_T, J_U);
     expect(false, J_T, A_T);
 
     expect(true, J_S, Object_);
     expect(false, J_S, num_);
     expect(false, J_S, int_);
     expect(false, J_S, String_);
-    expect(true, J_S, dynamic_, expectMoreSpecific: false);
+    expect(true, J_S, dynamic_);
     expect(false, J_S, J_T);
     expect(true, J_S, J_S);
     expect(true, J_S, J_U);
     expect(false, J_S, A_T);
 
     expect(true, J_U, Object_);
     expect(false, J_U, num_);
     expect(false, J_U, int_);
     expect(false, J_U, String_);
-    expect(true, J_U, dynamic_, expectMoreSpecific: false);
+    expect(true, J_U, dynamic_);
     expect(false, J_U, J_T);
     expect(true, J_U, J_S);
     expect(true, J_U, J_U);
     expect(false, J_U, A_T);
   }));
 }