Use a shared function to represent type substitutions with dynamic.

sdk/lib/_internal/compiler/js_lib/js_rti.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.
 
 /**
  * This part contains helpers for supporting runtime type information.
  *
  * The helper use a mixture of Dart and JavaScript objects. To indicate which is
  * used where we adopt the scheme of using explicit type annotation for Dart
  * objects and 'var' or omitted return type for JavaScript objects.
@@ skipping 19 matching lines @@
  * To check subtype relations between generic classes we use a JavaScript
  * expression that describes the necessary substitution for type arguments.
  * Such a substitution expresssion can be:
  *  1) `null`, if no substituted check is necessary, because the
  *     type variables are the same or there are no type variables in the class
  *     that is checked for.
  *  2) A list expression describing the type arguments to be used in the
  *     subtype check, if the type arguments to be used in the check do not
  *     depend on the type arguments of the object.
  *  3) A function mapping the type variables of the object to be checked to
- *     a list expression.
+ *     a list expression. The function may also return null, which is equivalent

[karlklose, 2015/01/20 10:37:32]

"null" -> "`null`".

+ *     to an array containing only null values.
  */
 
 part of _js_helper;
 
 Type createRuntimeType(String name) => new TypeImpl(name);
 
 class TypeImpl implements Type {
   final String _typeName;
   String _unmangledName;
 
@@ skipping 178 matching lines @@
  *
  * See the comment in the beginning of this file for a description of the
  * possible values for [substitution].
  */
 substitute(var substitution, var arguments) {
   assert(substitution == null ||
          isJsFunction(substitution));
   assert(arguments == null || isJsArray(arguments));
   if (isJsFunction(substitution)) {
     substitution = invoke(substitution, arguments);
-    if (isJsArray(substitution)) {
+    if (substitution == null || isJsArray(substitution)) {
       arguments = substitution;
     } else if (isJsFunction(substitution)) {
       // TODO(johnniwinther): Check if this is still needed.
       arguments = invoke(substitution, arguments);
     }
   }
   return arguments;
 }
 
 /**
@@ skipping 429 matching lines @@
  * `null` and `undefined` (which we can avoid).
  */
 bool isIdentical(var s, var t) => JS('bool', '# === #', s, t);
 
 /**
  * Returns `true` if the JavaScript values [s] and [t] are not identical. We use
  * this helper instead of [identical] because `identical` needs to merge
  * `null` and `undefined` (which we can avoid).
  */
 bool isNotIdentical(var s, var t) => JS('bool', '# !== #', s, t);