No dynamic at runtime

lib/src/codegen/js_codegen.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.
 
 library dev_compiler.src.codegen.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 582 matching lines @@
           var name = node.name.name;
           var element = node.element;
           var inheritedElement =
               classElem.lookUpInheritedConcreteMethod(name, currentLibrary);
           if (inheritedElement != null &&
               inheritedElement.type == element.type) continue;
           var unary = node.parameters.parameters.isEmpty;
           var memberName = _emitMemberName(name,
               type: cType, unary: unary, isStatic: node.isStatic);
           var property =
-              new JS.Property(memberName, _emitTypeName(element.type));
+              new JS.Property(memberName, _emitFunctionRTTI(element.type));
           if (node.isStatic) {
             tStatics.add(property);
             sNames.add(memberName);
           } else tMethods.add(property);
         }
       }
       build(name, elements) {
         var o =
             new JS.ObjectInitializer(elements, vertical: elements.length > 1);
         var e = js.call('() => #', o);
@@ skipping 404 matching lines @@
     var lazy = topLevel && !_typeIsLoaded(type);
 
     if (type is FunctionType && (name == '' || name == null)) {
       if (type.returnType.isDynamic &&
           type.optionalParameterTypes.isEmpty &&
           type.namedParameterTypes.isEmpty &&
           type.normalParameterTypes.every((t) => t.isDynamic)) {
         return js.call('dart.fn(#)', [clos]);
       }
       if (lazy) {
-        return js.call('dart.fn(#, () => #)', [clos, _emitTypeName(type)]);
+        return js.call('dart.fn(#, () => #)', [clos, _emitFunctionRTTI(type)]);
       }
-      return js.call('dart.fn(#, #)', [clos, _emitFunctionTypeParts(type)]);
+      return js.call('dart.fn(#, #)', [
+        clos,
+        _emitFunctionTypeParts(type, dynamicIsObject: true)
+      ]);
     }
     throw 'Function has non function type: $type';
   }
 
   @override
   JS.Expression visitFunctionExpression(FunctionExpression node) {
     var params = _visit(node.parameters);
     if (params == null) params = [];
 
     var parent = node.parent;
@@ skipping 111 matching lines @@
         return _getTemp(element, name);
       }
     }
 
     return new JS.Identifier(name);
   }
 
   JS.TemporaryId _getTemp(Object key, String name) =>
       _temps.putIfAbsent(key, () => new JS.TemporaryId(name));
 
-  JS.ArrayInitializer _emitTypeNames(List<DartType> types) {
-    return new JS.ArrayInitializer(types.map(_emitTypeName).toList());
+  JS.ArrayInitializer _emitTypeNames(List<DartType> types,
+      {dynamicIsBottom: false}) {
+    var build = (t) => _emitTypeName(t, dynamicIsBottom: dynamicIsBottom);
+    return new JS.ArrayInitializer(types.map(build).toList());
   }
 
-  JS.ObjectInitializer _emitTypeProperties(Map<String, DartType> types) {
+  JS.ObjectInitializer _emitTypeProperties(Map<String, DartType> types,
+      {dynamicIsBottom: false}) {
     var properties = <JS.Property>[];
     types.forEach((name, type) {
       var key = new JS.LiteralString(name);
-      var value = _emitTypeName(type);
+      var value = _emitTypeName(type, dynamicIsBottom: dynamicIsBottom);
       properties.add(new JS.Property(key, value));
     });
     return new JS.ObjectInitializer(properties);
   }
 
-  List<JS.Expression> _emitFunctionTypeParts(FunctionType type) {
+  /// Emit the pieces of a function type, as an array of return type,
+  /// regular args, and optional/named args.
+  /// If [dynamicIsObject] is set, then dynamics in argument positions
+  /// will be lowered to Object instead of bottom.
+  List<JS.Expression> _emitFunctionTypeParts(FunctionType type,
+      {bool dynamicIsObject: false}) {

[vsm, 2015/05/20 23:03:10]

Perhaps use either dynamicIsBottom here or dynamicIsObject above consistently?

[Leaf, 2015/05/20 23:35:28]

Done.

     var returnType = type.returnType;
     var parameterTypes = type.normalParameterTypes;
     var optionalTypes = type.optionalParameterTypes;
     var namedTypes = type.namedParameterTypes;
     var rt = _emitTypeName(returnType);
-    var ra = _emitTypeNames(parameterTypes);
+    var ra = _emitTypeNames(parameterTypes, dynamicIsBottom: !dynamicIsObject);
     if (!namedTypes.isEmpty) {
       assert(optionalTypes.isEmpty);
-      var na = _emitTypeProperties(namedTypes);
+      var na =
+          _emitTypeProperties(namedTypes, dynamicIsBottom: !dynamicIsObject);
       return [rt, ra, na];
     }
     if (!optionalTypes.isEmpty) {
       assert(namedTypes.isEmpty);
-      var oa = _emitTypeNames(optionalTypes);
+      var oa = _emitTypeNames(optionalTypes, dynamicIsBottom: !dynamicIsObject);
       return [rt, ra, oa];
     }
     return [rt, ra];
   }
 
+  JS.Expression _emitFunctionRTTI(FunctionType type) {
+    var parts = _emitFunctionTypeParts(type, dynamicIsObject: true);
+    return js.call('dart.functionType(#)', [parts]);
+  }
+
   /// Emits a Dart [type] into code.
   ///
   /// If [lowerTypedef] is set, a typedef will be expanded as if it were a
   /// function type. Similarly if [lowerGeneric] is set, the `List$()` form
   /// will be used instead of `List`. These flags are used when generating
   /// the definitions for typedefs and generic types, respectively.
-  JS.Expression _emitTypeName(DartType type,
-      {bool lowerTypedef: false, bool lowerGeneric: false}) {
+  JS.Expression _emitTypeName(DartType type, {bool lowerTypedef: false,
+      bool lowerGeneric: false, bool dynamicIsBottom: false}) {
 
     // The void and dynamic types are not defined in core.
     if (type.isVoid) {
       return js.call('dart.void');
     } else if (type.isDynamic) {
-      return js.call('dart.dynamic');
+      if (dynamicIsBottom) return js.call('dart.bottom');
+      return _emitTypeName(types.objectType);
     } else if (type.isBottom) {
       return js.call('dart.bottom');
     }
 
     _loader.declareBeforeUse(type.element);
 
     // TODO(jmesserly): like constants, should we hoist function types out of
     // methods? Similar issue with generic types. For all of these, we may want
     // to canonicalize them too, at least when inside the same library.
     var name = type.name;
@@ skipping 1362 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }