Handle dynamic as bottom inside of function type reps

lib/runtime/_rtti.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 association between runtime objects and
  * runtime types.
 */
 
 dart_library.library('dart_runtime/_rtti', null, /* Imports */[
 ], /* Lazy Imports */[
   'dart/core',
   'dart_runtime/_types'
 ], function(exports, core, types) {
   'use strict';
 
   const defineLazyProperty = dart_utils.defineLazyProperty;
 
   const defineProperty = Object.defineProperty;
 
   const slice = [].slice;
 
   /**
+   * Runtime type information.  This module defines the mapping from
+   * runtime objects to their runtime type information.  See the types
+   * module for the definition of how type information is represented.
+   *
+   * Runtime objects fall into four main categories:
+   *
+   *   - Things represented by javascript primitives, such as
+   *     null, numbers, booleans, strings, and symbols.  For these
+   *     we map directly from the javascript type (given by typeof)
+   *     to the appropriate class type from core, which serves as their
+   *     rtti.
+   *
+   *   - Functions, which are represented by javascript functions.
+   *     Representations of Dart functions always have a
+   *     _runtimeType property attached to them with the appropriate
+   *     rtti.
+   *
+   *   - Objects (instances) which are represented by instances of
+   *     javascript (ES6) classes.  Their types are given by their
+   *     classes, and the rtti is accessed by projecting out their
+   *     constructor field.
+   *
+   *   - Types objects, which are represented as described in the types
+   *     module.  Types always have a _runtimeType property attached to
+   *     them with the appropriate rtti.  The rtti for these is always
+   *     core.Type.  TODO(leafp): consider the possibility that we can
+   *     reliably recognize type objects and map directly to core.Type
+   *     rather than attaching this property everywhere.
+   *
+   */
+
+  /**
    *Tag a closure with a type, using one of three forms:
    * dart.fn(cls) marks cls has having no optional or named
    *  parameters, with all argument and return types as dynamic
    * dart.fn(cls, func) marks cls with the lazily computed
    *  runtime type as computed by func()
    * dart.fn(cls, rType, argsT, extras) marks cls as having the
    * runtime type dart.functionType(rType, argsT, extras)
+   *
+   * Note that since we are producing a type for a concrete function,
+   * it is sound to use the definite arrow type.
    */
   function fn(closure/* ...args*/) {
     // Closure and a lazy type constructor
     if (arguments.length == 2) {
       defineLazyProperty(closure, _runtimeType, {get : arguments[1]});
       return closure;
     }
     let t;
     if (arguments.length == 1) {
       // No type arguments, it's all dynamic
       let len = closure.length;
-      let build = () => {
-        let args = Array.apply(null, new Array(len)).map(() => core.Object);
-        return types.functionType(core.Object, args);
-      };
-      // We could be called before Object is defined.
-      if (core.Object === void 0) return fn(closure, build);
-      t = build();
+      let args = Array.apply(null, new Array(len)).map(() => types.dynamic);
+      t = types.definiteFunctionType(types.dynamic, args);
     } else {
       // We're passed the piecewise components of the function type,
       // construct it.
       let args = slice.call(arguments, 1);
-      t = types.functionType.apply(null, args);
+      t = types.definiteFunctionType.apply(null, args);
     }
     tag(closure, t);
     return closure;
   }
   exports.fn = fn;
 
   // TODO(vsm): How should we encode the runtime type?
   const _runtimeType = Symbol('_runtimeType');
 
   function checkPrimitiveType(obj) {
@@ skipping 15 matching lines @@
     return null;
   }
 
   function runtimeType(obj) {
     let result = checkPrimitiveType(obj);
     if (result !== null) return result;
     return obj.runtimeType;
   }
   exports.runtimeType = runtimeType;
 
   function getFunctionType(obj) {

[vsm, 2015/06/17 22:43:13]

Do we still use this method?  I wrote this before you actually stored function
types properly.

[Leaf, 2015/06/17 22:53:07]

Currently I believe that it will make javascript functions be treated as having
the least specific function type of the appropriate arity (Top^n => Bot).  I'm
not sure if we want or need this right now.  See realRuntimeType below for the
only call site.

     // TODO(vsm): Encode this properly on the function for Dart-generated code.
-    let args = Array.apply(null, new Array(obj.length)).map(() => core.Object);
-    return types.functionType(types.bottom, args);
+    let args = Array.apply(null, new Array(obj.length)).map(() => classes.dynamic);

[vsm, 2015/06/17 22:43:13]

(nit: length) Should this be types.dynamic?

[Leaf, 2015/06/17 22:53:07]

Yes, fixed but forgot to upload before sending.  good catch.  :)

+    return types.definiteFunctionType(types.bottom, args);
   }
 
   /**
    * Returns the runtime type of obj. This is the same as `obj.realRuntimeType`
    * but will not call an overridden getter.
    *
    * Currently this will return null for non-Dart objects.
    */
   function realRuntimeType(obj) {
     let result = checkPrimitiveType(obj);
@@ skipping 38 matching lines @@
     function getter() {
       if (compute == null) return cache;
       cache = compute();
       compute = null;
       return cache;
     }
     tagComputed(value, getter);
   }
   exports.tagMemoized = tagMemoized;
 });