fix #29789, avoid unneccessary dcalls and checks in dart:_runtime

pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/types.dart

 // 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.
 
 /// This library defines the representation of runtime types.
 part of dart._runtime;
 
 final metadata = JS('', 'Symbol("metadata")');
 
 /// The symbol used to store the cached `Type` object associated with a class.
@@ skipping 290 matching lines @@
  result = new $FunctionType.new($returnType, args, [], {});
  map.set($returnType, result);
  return result;
 })()''');
 
 class FunctionType extends AbstractFunctionType {
   final returnType;
   List args;
   List optionals;
   final named;
-  dynamic metadata;
+  // TODO(vsm): This is just parameter metadata for now.
+  List metadata = [];
   String _stringValue;
 
   /**
    * Construct a function type. There are two arrow constructors,
    * distinguished by the "definite" flag.
    *
    * The fuzzy arrow (definite is false) treats any arguments
    * of type dynamic as having type bottom, and will always be
    * called with a dynamic invoke.
    *
@@ skipping 27 matching lines @@
       create =
           () => new FunctionType(returnType, args, optionals, JS('', '{}'));
     } else {
       var named = _canonicalizeNamed(definite, extra, _fnTypeNamedArgMap);
       keys = [returnType, args, named];
       create = () => new FunctionType(returnType, args, [], named);
     }
     return _memoizeArray(_fnTypeTypeMap, keys, create);
   }
 
-  List _process(List array, metadata) {
+  List _process(List array) {
     var result = [];
     for (var i = 0; JS('bool', '# < #.length', i, array); ++i) {
       var arg = JS('', '#[#]', array, i);
       if (JS('bool', '# instanceof Array', arg)) {
-        metadata.add(JS('', '#.slice(1)', arg));
-        result.add(JS('', '#[0]', arg));
+        JS('', '#.push(#.slice(1))', metadata, arg);
+        JS('', '#.push(#[0])', result, arg);
       } else {
         JS('', '#.push([])', metadata);
         JS('', '#.push(#)', result, arg);
       }
     }
     return result;
   }
 
   FunctionType(this.returnType, this.args, this.optionals, this.named) {
-    // TODO(vsm): This is just parameter metadata for now.
-    metadata = [];
-    this.args = _process(this.args, metadata);
-    this.optionals = _process(this.optionals, metadata);
+    this.args = _process(this.args);
+    this.optionals = _process(this.optionals);
     // TODO(vsm): Add named arguments.
   }
 
   toString() => name;
 
   get name {
     if (_stringValue != null) return _stringValue;
 
     var buffer = '(';
     for (var i = 0; JS('bool', '# < #.length', i, args); ++i) {
@@ skipping 29 matching lines @@
 
     var returnTypeName = typeName(returnType);
     buffer += ') -> $returnTypeName';
     _stringValue = buffer;
     return buffer;
   }
 }
 
 class Typedef extends AbstractFunctionType {
   dynamic _name;
-  dynamic _closure;
+  AbstractFunctionType Function() _closure;
   AbstractFunctionType _functionType;
 
   Typedef(this._name, this._closure) {}
 
-  toString() => JS('', '# + "(" + #.toString() + ")"', _name, functionType);
+  toString() =>
+      JS('String', '# + "(" + #.toString() + ")"', _name, functionType);
   get name => _name;
 
   AbstractFunctionType get functionType {
-    return _functionType ??= JS('', '#()', _closure);
+    var ft = _functionType;
+    return ft == null ? _functionType = _closure() : ft;
   }
 }
 
 /// A type variable, used by [GenericFunctionType] to represent a type formal.
 class TypeVariable extends TypeRep {
   final String name;
 
   TypeVariable(this.name);
 
   toString() => name;
@@ skipping 146 matching lines @@
     if (partials.isNotEmpty) {
       throwStrongModeError('Instantiate to bounds failed for type with '
           'recursive generic bounds: ${typeName(this)}. '
           'Try passing explicit type arguments.');
     }
 
     return defaults;
   }
 }
 
-typedef(name, closure) => new Typedef(name, closure);
+typedef(name, AbstractFunctionType Function() closure) =>
+    new Typedef(name, closure);
 
 /// Create a definite function type.
 ///
 /// No substitution of dynamic for bottom occurs.
 fnType(returnType, List args, extra) =>
     FunctionType.create(true, returnType, args, extra);
 
 /// Create a "fuzzy" function type.
 ///
 /// If any arguments are dynamic they will be replaced with bottom.
@@ skipping 440 matching lines @@
     return true;
   }
 
   let typeArgs = $getGenericArgs($type);
   if (!typeArgs) return true;
   for (let t of typeArgs) {
     if (t != $Object && t != $dynamic) return false;
   }
   return true;
 })()''');