Handle dynamic as bottom inside of function type reps

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, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 629 matching lines @@
       var sNames = [];
       for (MethodDeclaration node in methods) {
         if (!(node.isSetter || node.isGetter || node.isAbstract)) {
           var name = node.name.name;
           var element = node.element;
           var inheritedElement =
               classElem.lookUpInheritedConcreteMethod(name, currentLibrary);
           if (inheritedElement != null &&
               inheritedElement.type == element.type) continue;
           var memberName = _elementMemberName(element);
-          var parts =
-              _emitFunctionTypeParts(element.type, dynamicIsBottom: false);
+          var parts = _emitFunctionTypeParts(element.type);
           var property =
               new JS.Property(memberName, new JS.ArrayInitializer(parts));
           if (node.isStatic) {
             tStatics.add(property);
             sNames.add(memberName);
           } else {
             tMethods.add(property);
           }
         }
       }
 
       var tCtors = [];
       for (ConstructorDeclaration node in ctors) {
         var memberName = _constructorName(node.element);
         var element = node.element;
-        var parts =
-            _emitFunctionTypeParts(element.type, dynamicIsBottom: false);
+        var parts = _emitFunctionTypeParts(element.type);
         var property =
             new JS.Property(memberName, new JS.ArrayInitializer(parts));
         tCtors.add(property);
       }
 
       build(name, elements) {
         var o =
             new JS.ObjectInitializer(elements, multiline: elements.length > 1);
         var e = js.call('() => #', o);
         var p = new JS.Property(_propertyName(name), e);
@@ skipping 499 matching lines @@
     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, _emitFunctionRTTI(type)]);
       }
-      return js.call('dart.fn(#, #)', [
-        clos,
-        _emitFunctionTypeParts(type, dynamicIsBottom: false)
-      ]);
+      return js.call('dart.fn(#, #)', [clos, _emitFunctionTypeParts(type)]);
     }
     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 112 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,
-      {dynamicIsBottom: false}) {
-    var build = (t) => _emitTypeName(t, dynamicIsBottom: dynamicIsBottom);
+  JS.ArrayInitializer _emitTypeNames(List<DartType> types) {
+    var build = (t) => _emitTypeName(t);
     return new JS.ArrayInitializer(types.map(build).toList());
   }
 
-  JS.ObjectInitializer _emitTypeProperties(Map<String, DartType> types,
-      {dynamicIsBottom: false}) {
+  JS.ObjectInitializer _emitTypeProperties(Map<String, DartType> types) {
     var properties = <JS.Property>[];
     types.forEach((name, type) {
       var key = _propertyName(name);
-      var value = _emitTypeName(type, dynamicIsBottom: dynamicIsBottom);
+      var value = _emitTypeName(type);
       properties.add(new JS.Property(key, value));
     });
     return new JS.ObjectInitializer(properties);
   }
 
   /// Emit the pieces of a function type, as an array of return type,
   /// regular args, and optional/named args.
-  /// If [dynamicIsBottom] is true, then dynamics in argument positions
-  /// will be lowered to bottom instead of Object.
-  List<JS.Expression> _emitFunctionTypeParts(FunctionType type,
-      {bool dynamicIsBottom: true}) {
+  List<JS.Expression> _emitFunctionTypeParts(FunctionType type) {
     var returnType = type.returnType;
     var parameterTypes = type.normalParameterTypes;
     var optionalTypes = type.optionalParameterTypes;
     var namedTypes = type.namedParameterTypes;
     var rt = _emitTypeName(returnType);
-    var ra = _emitTypeNames(parameterTypes, dynamicIsBottom: dynamicIsBottom);
+    var ra = _emitTypeNames(parameterTypes);
     if (!namedTypes.isEmpty) {
       assert(optionalTypes.isEmpty);
-      var na =
-          _emitTypeProperties(namedTypes, dynamicIsBottom: dynamicIsBottom);
+      var na = _emitTypeProperties(namedTypes);
       return [rt, ra, na];
     }
     if (!optionalTypes.isEmpty) {
       assert(namedTypes.isEmpty);
-      var oa = _emitTypeNames(optionalTypes, dynamicIsBottom: dynamicIsBottom);
+      var oa = _emitTypeNames(optionalTypes);
       return [rt, ra, oa];
     }
     return [rt, ra];
   }
 
   JS.Expression _emitFunctionRTTI(FunctionType type) {
-    var parts = _emitFunctionTypeParts(type, dynamicIsBottom: false);
-    return js.call('dart.functionType(#)', [parts]);
+    var parts = _emitFunctionTypeParts(type);
+    return js.call('dart.definiteFunctionType(#)', [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, bool dynamicIsBottom: false}) {
+  JS.Expression _emitTypeName(DartType type,
+      {bool lowerTypedef: false, bool lowerGeneric: false}) {
 
     // The void and dynamic types are not defined in core.
     if (type.isVoid) {
       return js.call('dart.void');
     } else if (type.isDynamic) {
-      if (dynamicIsBottom) return js.call('dart.bottom');
-      return _emitTypeName(types.objectType);
+      return js.call('dart.dynamic');
     } 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 1405 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);
 }