Reduces code generated by dynamic calls.

frog/value.dart

 // 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.
 
 /**
  * Represents a meta-value for code generation.
  */
 class Value {
   /** The [Type] of the [Value]. */
   Type type;
@@ skipping 27 matching lines @@
     }
     // member.get_ returns null if no signatures match the given node.
     if (member != null) {
       return member;
     } else {
       return invokeNoSuchMethod(context, 'get:$name', node);
     }
   }
 
   set_(MethodGenerator context, String name, Node node, Value value,
-      [bool checked=true]) {
+      [bool isDynamic=false]) {
     var member = _resolveMember(context, name, node);
     if (member != null) {
-      member = member.set_(context, node, this, value, checked);
+      member = member.set_(context, node, this, value, isDynamic);
     }
     // member.set_ returns null if no signatures match the given node.
     if (member != null) {
       return member;
     } else {
       return invokeNoSuchMethod(context, 'set:$name', node,
           new Arguments(null, [value]));
     }
   }
 
   invoke(MethodGenerator context, String name, Node node, Arguments args,
-      [bool checked=true]) {
+      [bool isDynamic=false]) {
     // TODO(jimhug): The != method is weird - understand it better.
     if (type.isVar && name == '\$ne') {
       if (args.values.length != 1) {
         world.warning('wrong number of arguments for !=', node.span);
       }
       return new Value(null, '\$ne($code, ${args.values[0].code})');
     }
 
     // TODO(jmesserly): it'd be nice to remove these special cases
     // We could create a $call (and $ne) in world members, and have
@@ skipping 10 matching lines @@
       }
       if (type.needsVarCall(args)) {
         return _varCall(context, args);
       }
     }
 
     var member = _resolveMember(context, name, node);
     if (member == null) {
       return invokeNoSuchMethod(context, name, node, args);
     } else {
-      return member.invoke(context, node, this, args, checked);
+      return member.invoke(context, node, this, args, isDynamic);
     }
   }
 
   bool canInvoke(MethodGenerator context, String name, Arguments args) {
     // TODO(jimhug): The != method is weird - understand it better.
     if (type.isVar && name == '\$ne') {
       return true;
     }
 
     if (type.isVarOrFunction && name == '\$call') {
@@ skipping 51 matching lines @@
   }
 
   /** Generate a call to an unknown function type. */
   Value _varCall(MethodGenerator context, Arguments args) {
     var stub = world.functionType.getCallStub(args);
     return new Value(null, '$code.${stub.name}(${args.getCode()})');
   }
 
   /**
    * Assign or convert this value to another type.
-   * Right now we use this for converting between function types. In the future
-   * we can use this for other kinds of type checks.
+   * This is used for converting between function types, and inserting type
+   * checks when --enable_type_checks is enabled.
    */
   Value convertTo(MethodGenerator context, Type toType, Node node,
-      [bool checked=true]) {
+      [bool isDynamic=false]) {
+
+    // Check types if enabled, unless this is a dynamic operation
+    bool checked = options.enableTypeChecks && !isDynamic;
 
     var callMethod = toType.getCallMethod();
     if (callMethod != null) {
-      if (checked && options.enableTypeChecks && !toType.isAssignable(type)) {
+      if (checked && !toType.isAssignable(type)) {
         convertWarning(toType, node);
       }
 
-      // TODO(jmesserly): better error if passing a non-function to something
-      // that expects a function.
-
       int arity = callMethod.parameters.length;
       var myCall = type.getCallMethod();
       if (myCall == null || myCall.parameters.length != arity) {
         final stub = world.functionType.getCallStub(new Arguments.bare(arity));
         return new Value(toType, 'to\$${stub.name}($code)');
       }
     }
 
+    // Don't add runtime asserts unless we have type checks turned on.
     if (!options.enableTypeChecks) {
       return this;
     }
 
     if (type.isSubtypeOf(toType)) {
       return this; // widening conversion
     } else if (checked && !toType.isSubtypeOf(type)) {
       // According to the static types, this conversion can't work.
       convertWarning(toType, node);
     }
 
-    // Add a runtime type check
+    return _typeAssert(context, toType, node);
+  }
 
+  /**
+   * Generates a run time type assertion for the given value. This works like
+   * [instanceOf], but it allows null since Dart types are nullable.
+   * Also it will throw a TypeError if it gets the wrong type.
+   */
+  // TODO(jmesserly): this generated code is too verbose.
+  Value _typeAssert(MethodGenerator context, Type toType, Node node) {
+    if (toType is ParameterType) {
+      ParameterType p = toType;
+      toType = p.extendsType;
+    }
+
+    // TODO(jmesserly): I don't like the duplication with instanceOf
     var temp = context.getTemp(this);
-    var test = context.assignTemp(temp, this);
-    // TODO(jmesserly): this generates a second temp because of assignTemp
-    // Also it generates an unecessary !!.
-    test = test.instanceOf(context, toType, node.span);
+    String testCode;
+    if (toType.library.isCore && toType.typeofName != null) {
+      testCode = "typeof(${temp.code}) == '${toType.typeofName}'";
+    } else if (toType.isClass && toType is !ConcreteType) {
+      toType.markUsed();
+      testCode = '${temp.code} instanceof ${toType.jsname}';
+    } else {
+      toType.isTested = true;
+      testCode = '${temp.code}.is\$${toType.jsname}';
+    }
+    testCode = '(${context.assignTemp(temp, this).code} == null || $testCode)';
+    var test = new Value(world.boolType, testCode);
 
-    // TODO(jmesserly): this generated code is too verbose
     var err = world.corelib.types['TypeError'];
     world.gen.genMethod(err.members['toString']);
     var args = new Arguments(null, [temp,
         new Value(world.stringType, '"${toType.name}"')]);
     var typeErr = err.getConstructor('').invoke(context, node, null, args);
 
     var result = new Value(toType, '(${test.code} ? ${temp.code} : '
         + '\$throw(${typeErr.code}))');
     if (temp != this) context.freeTemp(temp);
     return result;
@@ skipping 50 matching lines @@
         // The single ! here nicely converts undefined to false and function
         // to true.
         testCode = '!' + testCode;
       }
       if (this != temp) context.freeTemp(temp);
     }
     return new Value(world.boolType, testCode);
   }
 
   void convertWarning(Type toType, Node node) {
+    // TODO(jmesserly): better error messages for type conversion failures
     world.warning('type "${type.name}" is not assignable to "${toType.name}"',
         node.span);
   }
 
   Value invokeNoSuchMethod(MethodGenerator context, String name, Node node,
       [Arguments args]) {
     var pos = '';
     if (args != null) {
       var argsCode = [];
       for (int i = 0; i < args.length; i++) {
@@ skipping 205 matching lines @@
       return 1;
     } else if (name != null && other.name == null) {
       return -1;
     } else if (name != null) {
       return name.compareTo(other.name);
     } else {
       return field.name.compareTo(other.field.name);
     }
   }
 }