Fix subtyping for generic typedefs. Generic typedefs were being

test/browser/runtime_tests.js

 // 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.
 
 var assert = chai.assert;
 var dart_sdk = dart_library.import('dart_sdk');
 var core = dart_sdk.core;
 var collection = dart_sdk.collection;
 var dart = dart_sdk.dart;
 var dartx = dart.dartx;
@@ skipping 791 matching lines @@
   }
   function never2(t1, t2) {
     assert.equal(isSubtype(t1, t2), false);
     maybe(functionType(t1, [t2]), functionType(t2, [t1]));
   }
   function maybe2(t1, t2) {
     assert.equal(isSubtype(t1, t2), null);
     maybe(functionType(t1, [t2]), functionType(t2, [t1]));
   }
 
+  function run_test(func1, func2, func2opt, func1extra, func2extra) {
+    always2(func2(int, int), func2(int, int));
+    always2(func2(int, num), func2(int, int));
+    always2(func2(int, int), func2(num, int));
+
+    always2(func2opt(int, int), func2opt(int, int));
+    always2(func2opt(int, num), func2opt(int, int));
+    always2(func2opt(int, int), func2opt(num, int));
+
+    always2(func2opt(int, int), func2(int, int));
+    always2(func2opt(int, num), func2(int, int));
+    always2(func2opt(int, int), func2(num, int));
+
+    always2(func2opt(int, int), func1(int));
+    always2(func2opt(int, num), func1(int));
+    always2(func2opt(int, int), func1(num));
+
+    always2(func2extra(int, int), func2(int, int));
+    always2(func2extra(int, num), func2(int, int));
+    always2(func2extra(int, int), func2(num, int));
+
+    maybe2(func2(int, int), func2(int, num));
+    maybe2(func2(num, int), func2(int, int));
+
+    maybe2(func2opt(num, num), func1(int));
+
+    maybe2(func2opt(int, int), func2opt(int, num));
+    maybe2(func2opt(num, int), func2opt(int, int));
+
+    maybe2(func2opt(int, int), func2(int, num));
+    maybe2(func2opt(num, int), func2(int, int));
+
+    maybe2(func2extra(int, int), func2(int, num));
+    maybe2(func2extra(num, int), func2(int, int));
+
+    never2(func1(int), func2(int, num));
+    never2(func1(num), func2(int, int));
+    never2(func1(num), func2(num, num));
+
+    never2(func2(int, int), func1(int));
+    never2(func2(num, int), func1(int));
+    never2(func2(num, num), func1(num));
+
+    never2(func1(int), func2opt(int, num));
+    never2(func1(num), func2opt(int, int));
+    never2(func1(num), func2opt(num, num));
+
+    never2(func2(int, int), func2opt(int, num));
+    never2(func2(num, int), func2opt(int, int));
+    never2(func2(num, num), func2opt(num, num));
+
+    never2(func1extra(int), func2(int, num));
+    never2(func1extra(num), func2(int, int));
+    never2(func1extra(num), func2(num, num));
+
+    never2(func1extra(int), func2opt(int, num));
+    never2(func1extra(num), func2opt(int, int));
+    never2(func1extra(num), func2opt(num, num));
+
+    never2(func1(int), func1extra(int));
+    never2(func1(num), func1extra(int));
+    never2(func1(num), func1extra(num));
+
+    never2(func2(int, int), func1extra(int));
+    never2(func2(num, int), func1extra(int));
+    never2(func2(num, num), func1extra(num));
+
+    never2(func2(int, int), func2extra(int, int));
+    never2(func2(num, int), func2extra(int, int));
+    never2(func2(num, num), func2extra(num, num));
+  };
+
   test('basic function types', () => {
-    always2(functionType(int, [int]), functionType(int, [int]));
-    always2(functionType(int, [num]), functionType(int, [int]));
-    always2(functionType(int, [int]), functionType(num, [int]));
+    function func1(S) {
+      return functionType(S, []);
+    }
 
-    always2(functionType(int, [], [int]), functionType(int, [], [int]));
-    always2(functionType(int, [], [num]), functionType(int, [], [int]));
-    always2(functionType(int, [], [int]), functionType(num, [], [int]));
+    function func2(S, T) {
+      return functionType(S, [T]);
+    }
 
-    always2(functionType(int, [], [int]), functionType(int, [int]));
-    always2(functionType(int, [], [num]), functionType(int, [int]));
-    always2(functionType(int, [], [int]), functionType(num, [int]));
+    function func2opt(S, T) {
+      return functionType(S, [], [T]);
+    }
 
-    always2(functionType(int, [], [int]), functionType(int, []));
-    always2(functionType(int, [], [num]), functionType(int, []));
-    always2(functionType(int, [], [int]), functionType(num, []));
+    function func1extra(S) {
+      return functionType(S, [], {extra: int});
+    }
 
-    always2(functionType(int, [int], {extra: int}), functionType(int, [int]));
-    always2(functionType(int, [num], {extra: int}), functionType(int, [int]));
-    always2(functionType(int, [int], {extra: int}), functionType(num, [int]));
+    function func2extra(S, T) {
+      return functionType(S, [T], {extra: int});
+    }
 
-    maybe2(functionType(int, [int]), functionType(int, [num]));
-    maybe2(functionType(num, [int]), functionType(int, [int]));
+    run_test(func1, func2, func2opt, func1extra, func2extra);
+  });
 
-    maybe2(functionType(num, [], [num]), functionType(int, []));
+  test('basic typedefs', () => {
+    function func1(S) {
+      return dart.typedef('Func1', () => functionType(S, []))
+    }
 
-    maybe2(functionType(int, [], [int]), functionType(int, [], [num]));
-    maybe2(functionType(num, [], [int]), functionType(int, [], [int]));
+    function func2(S, T) {
+      return dart.typedef('Func2', () => functionType(S, [T]))
+    }
 
-    maybe2(functionType(int, [], [int]), functionType(int, [num]));
-    maybe2(functionType(num, [], [int]), functionType(int, [int]));
+    function func2opt(S, T) {
+      return dart.typedef('Func2', () => functionType(S, [], [T]))
+    }
 
-    maybe2(functionType(int, [int], {extra: int}), functionType(int, [num]));
-    maybe2(functionType(num, [int], {extra: int}), functionType(int, [int]));
+    function func1extra(S) {
+      return dart.typedef('Func1', () => functionType(S, [], {extra: int}))
+    }
 
-    never2(functionType(int, []), functionType(int, [num]));
-    never2(functionType(num, []), functionType(int, [int]));
-    never2(functionType(num, []), functionType(num, [num]));
+    function func2extra(S, T) {
+      return dart.typedef('Func2', () => functionType(S, [T], {extra: int}))
+    }
 
-    never2(functionType(int, [int]), functionType(int, []));
-    never2(functionType(num, [int]), functionType(int, []));
-    never2(functionType(num, [num]), functionType(num, []));
+    run_test(func1, func2, func2opt, func1extra, func2extra);
+  });
 
-    never2(functionType(int, []), functionType(int, [], [num]));
-    never2(functionType(num, []), functionType(int, [], [int]));
-    never2(functionType(num, []), functionType(num, [], [num]));
+  test('basic generic typedefs', () => {
+    let func1 = dart.generic(
+      (S) => dart.typedef('Func1', () => functionType(S, [])));
 
-    never2(functionType(int, [int]), functionType(int, [], [num]));
-    never2(functionType(num, [int]), functionType(int, [], [int]));
-    never2(functionType(num, [num]), functionType(num, [], [num]));
+    let func2 = dart.generic(
+      (S, T) => dart.typedef('Func2', () => functionType(S, [T])));
 
-    never2(functionType(int, [], {extra: int}), functionType(int, [num]));
-    never2(functionType(num, [], {extra: int}), functionType(int, [int]));
-    never2(functionType(num, [], {extra: int}), functionType(num, [num]));
+    let func2opt = dart.generic(
+      (S, T) => dart.typedef('Func2', () => functionType(S, [], [T])));
 
-    never2(functionType(int, [], {extra: int}), functionType(int, [], [num]));
-    never2(functionType(num, [], {extra: int}), functionType(int, [], [int]));
-    never2(functionType(num, [], {extra: int}), functionType(num, [], [num]));
+    let func1extra = dart.generic(
+      (S) => dart.typedef('Func1', () => functionType(S, [], {extra: int})));
 
-    never2(functionType(int, []), functionType(int, [], {extra: int}));
-    never2(functionType(num, []), functionType(int, [], {extra: int}));
-    never2(functionType(num, []), functionType(num, [], {extra: int}));
+    let func2extra = dart.generic(
+      (S, T) => dart.typedef('Func2',
+                             () => functionType(S, [T], {extra: int})));
 
-    never2(functionType(int, [int]), functionType(int, [], {extra: int}));
-    never2(functionType(num, [int]), functionType(int, [], {extra: int}));
-    never2(functionType(num, [num]), functionType(num, [], {extra: int}));
-
-    never2(functionType(int, [int]), functionType(int, [int], {extra: int}));
-    never2(functionType(num, [int]), functionType(int, [int], {extra: int}));
-    never2(functionType(num, [num]), functionType(num, [num], {extra: int}));
+    run_test(func1, func2, func2opt, func1extra, func2extra);
   });
 
   test('fuzzy function types', () => {
     always(functionType(int, [int]), functionType(dyn, [dyn]));
 
     always(functionType(int, [], [int]), functionType(dyn, [], [dyn]));
 
     always(functionType(int, [], [int]), functionType(dyn, [dyn]));
 
     always(functionType(int, [], [int]), functionType(dyn, []));
 
     always(functionType(int, [int], {extra: int}), functionType(dyn, [dyn]));
 
   });
 
+  test('higher-order typedef', () => {
+    let Func$ = dart.generic((S, T) =>
+                             dart.typedef('Func', () =>
+                                          functionType(T, [S])));
+    let Func2$ = dart.generic((R, S, T) =>
+                              dart.typedef('Func2', () =>
+                                           functionType(T, [Func$(R, S)])));
+
+    maybe(functionType(int, [functionType(int, [num])]),
+          functionType(num, [functionType(int, [int])]));
+    maybe(functionType(int, [Func$(num, int)]),
+          functionType(num, [Func$(int, int)]));
+    maybe(Func2$(num, int, int), Func2$(int, int, num));
+  });
+
   test('mixed types', () => {
     let AA$ = dart.generic((T) => class AA extends core.Object {});
 
     always(int, dyn);
     maybe(dyn, int);
 
     never(functionType(int, [int]), int);
 
     never(int, functionType(int, [int]));
 
@@ skipping 17 matching lines @@
 
 suite('primitives', function() {
   'use strict';
 
   test('fixed length list', () => {
     let list = new core.List(10);
     list[0] = 42;
     assert.throws(() => list.add(42));
   });
 });