Handle dynamic as bottom inside of function type reps

lib/runtime/_classes.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.
 
 /* This library defines the operations that define and manipulate Dart
  * classes.  Included in this are:
  *   - Generics
  *   - Class metadata
  *   - Extension methods
  */
@@ skipping 100 matching lines @@
     let length = typeConstructor.length;
     if (length < 1) {
       throwError('must have at least one generic type argument');
     }
     let resultMap = new Map();
     function makeGenericType(/*...arguments*/) {
       if (arguments.length != length && arguments.length != 0) {
         throwError('requires ' + length + ' or 0 type arguments');
       }
       let args = slice.call(arguments);
-      // TODO(leafp): This should really be core.Object for
-      // consistency, but Object is not attached to core
-      // until the entire core library has been processed,
-      // which is too late.
       while (args.length < length) args.push(types.dynamic);
 
       let value = resultMap;
       for (let i = 0; i < length; i++) {
         let arg = args[i];
         if (arg == null) {
           throwError('type arguments should not be null: '
                             + typeConstructor);
         }
         let map = value;
@@ skipping 33 matching lines @@
   let _staticSig = Symbol("sigStatic");
 
   /// Get the type of a method using the stored signature
   function _getMethodType(obj, name) {
     if (obj === void 0) return void 0;
     if (obj == null) return void 0;
     let sigObj = obj.__proto__.constructor[_methodSig];
     if (sigObj === void 0) return void 0;
     let parts = sigObj[name];
     if (parts === void 0) return void 0;
-    return types.functionType.apply(null, parts);
+    return types.definiteFunctionType.apply(null, parts);

[vsm, 2015/06/17 23:14:38]

Should these really be definite for instance methods?  See #129.

[Leaf, 2015/06/17 23:44:37]

I don't think this affects #129.  #129 has to do with what static type we use,
and how we generate code (e.g. either a dinvoke or not).  So in the checker, we
need to decide whether to expose methods as having a fuzzy type or a definite
type.  Currently I believe that we expose them as fuzzy, which is why the
override in #129 is allowed (and why a dinvoke is needed).

This on the other hand has to do with what runtime type we assign.  It is always
the case that definiteFunctionType(args) <: functionType(args), and so any
runtime type checks that used to succeed will still succeed (the runtime type
only appears on the left hand side of subtype checks).  Finally, it is always
safe to use a function at its definite type, since it is, by construction,
correct.

   }
 
   /// Get the type of a constructor from a class using the stored signature
   /// If name is undefined, returns the type of the default constructor
   /// Returns undefined if the constructor is not found.
   function _getConstructorType(cls, name) {
     if(!name) name = cls.name;
     if (cls === void 0) return void 0;
     if (cls == null) return void 0;
     let sigCtor = cls[_constructorSig];
     if (sigCtor === void 0) return void 0;
     let parts = sigCtor[name];
     if (parts === void 0) return void 0;
-    return types.functionType.apply(null, parts);
+    return types.definiteFunctionType.apply(null, parts);
   }
   exports.classGetConstructorType = _getConstructorType;
 
   /// Given an object and a method name, tear off the method.
   /// Sets the runtime type of the torn off method appropriately,
   /// and also binds the object.
   /// TODO(leafp): Consider caching the tearoff on the object?
   function bind(obj, name) {
     let f = obj[name].bind(obj);
     let sig = _getMethodType(obj, name);
@@ skipping 20 matching lines @@
   // Set up the static signature field on the constructor
   function _setStaticSignature(f, sigF) {
     defineMemoizedGetter(f, _staticSig, sigF);
   }
 
   // Set the lazily computed runtime type field on static methods
   function _setStaticTypes(f, names) {
     for (let name of names) {
       rtti.tagMemoized(f[name], function() {
         let parts = f[_staticSig][name];
-        return types.functionType.apply(null, parts);
+        return types.definiteFunctionType.apply(null, parts);
       })
     }
   }
 
   /// Set up the type signature of a class (constructor object)
   /// f is a constructor object
   /// signature is an object containing optional properties as follows:
   ///  methods: A function returning an object mapping method names
   ///   to method types.  The function is evaluated lazily and cached.
   ///  statics: A function returning an object mapping static method
@@ skipping 159 matching lines @@
   }
   exports.list = list;
 
   function setBaseClass(derived, base) {
     // Link the extension to the type it's extending as a base class.
     derived.prototype.__proto__ = base.prototype;
   }
   exports.setBaseClass = setBaseClass;
 
 });