Function type checking

compiler/lib/implementation/rtt.js

 // Copyright (c) 2011, 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.
 
 // The following methods are used to handle type information
 //
 
 /** 
  * @constructor
  * @param {string} classkey
  * @param {string=} typekey
  * @param {Array.<RTT>=} typeargs
+ * @param {RTT} returnType
+ * @param {bool} functionType
  */ 
-function RTT(classkey, typekey, typeargs) {
+function RTT(classkey, typekey, typeargs, returnType, functionType) {
   this.classKey = classkey;
   this.typeKey = typekey ? typekey : classkey;
   this.typeArgs = typeargs;
+  this.returnType = returnType; // key for the return type
   this.implementedTypes = {};
+  this.functionType = functionType;
   // Add self
   this.implementedTypes[classkey] = this;
   // Add Object
-  if (classkey != $cls('Object')) {
+  if (!functionType && classkey != $cls('Object')) {
     this.implementedTypes[$cls('Object')] = RTT.objectType;
   }
 }
 
 /** @type {Object.<string, Object>} */
 RTT.types = {};
 
 /** @type {Array.<RTT>} */
 RTT.prototype.derivedTypes = [];
 
 /** @return {string} */
 RTT.prototype.toString = function() { return this.typeKey; }
 
 /**
  * @param {*} value 
  * @return {boolean} Whether this type is implemented by the value
  */
 RTT.prototype.implementedBy = function(value){ 
   return (value == null) ? RTT.nullInstanceOf(this) :
+      this.functionType ? this.implementedByTypeFunc(value) :
       this.implementedByType(RTT.getTypeInfo(value)); 
 };
 
 /** 
  * A helper function for safely looking up a value
  * in a Object used as a map.
  * @param {Object.<*>} map
  * @param {srting} key
  * @return {*} the value or null;
  */
@@ skipping 17 matching lines @@
     for(var i = this.typeArgs.length - 1; i >= 0; i--) {
       if (!this.typeArgs[i].implementedByType(targetTypeInfo.typeArgs[i])) {
         return false;
       }
     }
   }
   return true;
 };
 
 /**
+ * @param {!RTT} other
+ * @return {boolean} Whether this type is implement by other
+ */
+RTT.prototype.implementedByTypeFunc = function(otherType) {
+  if (otherType === this || otherType === RTT.dynamicType) {
+    return true;
+  }
+  var found = true;
+  var props = Object.getOwnPropertyNames(otherType.implementedTypes);
+  for (var i = 0 ; i < props.length; i++) {
+    found = true;
+    var mapped = otherType.implementedTypes[props[i]];
+    if (mapped.returnType && this.returnType) {
+      if (!this.returnType.implementedByType(mapped.returnType)) {
+        continue;
+      }
+    } else if (mapped.returnType || this.returnType) {
+      continue; //handles mixed undef/defined.  undef/undef falls through
+    }
+    if (mapped.typeArgs && this.typeArgs) {
+      if (this.typeArgs.length != mapped.typeArgs.length) {
+        continue;
+      }
+      for(var x = this.typeArgs.length - 1; x >= 0; x--) {

[zundel, 2011/11/16 23:54:56]

style: space between for and (

[codefu, 2011/11/17 21:17:10]

Done.

+        if (!this.typeArgs[x].implementedByType(mapped.typeArgs[x])) {
+          found = false;

[zundel, 2011/11/16 23:54:56]

I find the use of 'found' in this method a bit confusing:

What you really want I think is to continue at the outer for loop.  You could
use a label on the outer loop and then use continue LABEL.

OUTER: for (var i = 0; i < probs.length; i++) {
    for (...) {
      continue OUTER;
    }
}
then you can get rid of the found variable all together.

[codefu, 2011/11/17 21:17:10]

Nice!

+          break; // fall through and search the next property
+        }
+      }
+    } else if (mapped.typeArgs || this.typeArgs) {
+      continue; //handles mixed undef/defined.  undef/undef falls through
+    }
+    if (found == true) {
+      return true;
+    }
+  }
+  return false;
+};
+
+/**
  * @return {string} the class name associated with this type
  */
 RTT.prototype.getClassName = function() {
   var name = this.classKey;
   if (name.substr(0, 4) == "cls:") {
     name = name.substr(4);
   }
   if (name.substr(-5) == "$Dart") {
     name = name.substr(0, name.length - 5);
   }
@@ skipping 38 matching lines @@
   var classkey = RTT.getTypeKey(name);
   rtt = new RTT(classkey, typekey, typeArgs);
   RTT.types[typekey] = rtt;
   if (implementsSupplier) {
     implementsSupplier(rtt, typeArgs);
   }
   return rtt;
 };
 
 /**
+ * @param {Array.<RTT>=} typeArgs
+ * @param {<RTT>=} returnType (if defined)
+ * @return {RTT} The RTT information object
+ */
+RTT.createFunction = function(typeArgs, returnType) {
+  var name = $cls("Function");
+  var typekey = RTT.getTypeKey(name, typeArgs, returnType);
+  var rtt = $mapLookup(RTT.types, typekey);
+  if (rtt) {
+    return rtt;
+  }
+  var classkey = RTT.getTypeKey(name);
+  rtt = new RTT(classkey, typekey, typeArgs, returnType, true);
+  RTT.types[typekey] = rtt;
+  return rtt;
+};
+
+/**
  * @param {string} classkey
  * @param {Array.<(RTT|string)>=} typeargs
+ * @param {string} returntype
  * @return {string}
  */
-RTT.getTypeKey = function(classkey, typeargs) {
+RTT.getTypeKey = function(classkey, typeargs, returntype) {
   var key = classkey;
   if (typeargs) {
     key += "<" + typeargs.join(",") + ">";
   }
+  if (returntype) {
+    key += "-><" + returntype + ">";
+  }
   return key;
 };
 
 /**
  * @return {*} value
  * @return {RTT} return the RTT information object for the value
  */
 RTT.getTypeInfo = function(value) {
   return (value.$typeInfo) ? value.$typeInfo : RTT.getNativeTypeInfo(value);
 };
@@ skipping 124 matching lines @@
   return typeof o == 'number';
 }
 
 /**
  * @param {*} o
  * @return {boolean}
  */
 function $isString(o) {
   return typeof o == 'string';
 }