Integrate leg as a component in test.py. Also update presubmit script to run tests with leg.

dart/frog/frogsh

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives core.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.
 
 // TODO(jimhug): Completeness - see tests/corelib
 
 /** Implements extends for dart classes on javascript prototypes. */
@@ skipping 4589 matching lines @@
       case const$191/*Keyword.CLASS*/:
 
         token = this.parseClass(token);
         break;
 
       case const$219/*Keyword.TYPEDEF*/:
 
         token = this.parseNamedFunctionAlias(token);
         break;
 
-      case const$237/*const SourceString("#")*/:
-
-        token = this.parseLibraryTags(token);
-        break;
-
       default:
 
-        token = this.parseTopLevelMember(token);
+        if ($eq(token.get$value(), const$237/*const SourceString("#")*/)) {
+          token = this.parseLibraryTags(token);
+        }
+        else {
+          token = this.parseTopLevelMember(token);
+        }
         break;
 
     }
   }
 }
 Parser.prototype.parseInterface = function(token) {
   this.listener.beginInterface(token);
   token = this.parseIdentifier(this.next(token));
   token = this.parseTypeVariablesOpt(token);
   token = this.parseSupertypesClauseOpt(token);
@@ skipping 654 matching lines @@
   this.interfaceCount = 0
   this.libraryTagCount = 0
   this.topLevelMemberCount = 0
   this.previousIdentifier = null
   this.canceler = canceler;
   this.builders = const$227/*const EmptyLink<DeclarationBuilder>()*/;
   this.topLevelElements = const$227/*const EmptyLink<DeclarationBuilder>()*/;
   // Initializers done
 }
 Listener.prototype.beginLibraryTag = function(token) {
+  this.canceler.cancel("Cannot handle library tags");
   this.libraryTagCount++;
 }
 Listener.prototype.beginClass = function(token) {
   this.classCount++;
   this.push(token, this.get$buildClassElement());
 }
 Listener.prototype.buildClassElement = function(declaration) {
-  return null;
+  this.canceler.cancel("Cannot handle classes");
 }
 Listener.prototype.get$buildClassElement = function() {
   return Listener.prototype.buildClassElement.bind(this);
 }
 Listener.prototype.endClass = function(token) {
   this.handleDeclaration(this.pop(), token);
 }
 Listener.prototype.beginInterface = function(token) {
   this.interfaceCount++;
   this.push(token, this.get$buildInterfaceElement());
 }
 Listener.prototype.buildInterfaceElement = function(declaration) {
-  return null;
+  this.canceler.cancel("Cannot handle interfaces");
 }
 Listener.prototype.get$buildInterfaceElement = function() {
   return Listener.prototype.buildInterfaceElement.bind(this);
 }
 Listener.prototype.endInterface = function(token) {
   this.handleDeclaration(this.pop(), token);
 }
 Listener.prototype.beginFunctionTypeAlias = function(token) {
   this.aliasCount++;
   this.push(token, this.get$buildFunctionTypeAliasElement());
 }
 Listener.prototype.buildFunctionTypeAliasElement = function(declaration) {
-  return null;
+  this.canceler.cancel("Cannot handle typedefs");
 }
 Listener.prototype.get$buildFunctionTypeAliasElement = function() {
   return Listener.prototype.buildFunctionTypeAliasElement.bind(this);
 }
 Listener.prototype.endFunctionTypeAlias = function(token) {
   this.handleDeclaration(this.pop(), token);
 }
 Listener.prototype.beginTopLevelMember = function(token) {
   this.topLevelMemberCount++;
 }
 Listener.prototype.topLevelMethod = function(token) {
   this.push(token, this.get$buildMethod());
   this.builders.get$head().name = this.previousIdentifier.get$source();
 }
 Listener.prototype.buildMethod = function(declaration) {
   return new PartialFunctionElement(declaration.name, declaration.beginToken, declaration.endToken);
 }
 Listener.prototype.get$buildMethod = function() {
   return Listener.prototype.buildMethod.bind(this);
 }
 Listener.prototype.topLevelField = function(token) {
   this.push(token, this.get$buildField());
   this.builders.get$head().name = this.previousIdentifier.get$source();
 }
 Listener.prototype.buildField = function(declaration) {
-  return null;
+  this.canceler.cancel("Cannot handle fields");
 }
 Listener.prototype.get$buildField = function() {
   return Listener.prototype.buildField.bind(this);
 }
 Listener.prototype.endTopLevelMember = function(token) {
   this.handleDeclaration(this.pop(), token);
 }
 Listener.prototype.beginTypeVariable = function(token) {
 
 }
@@ skipping 2325 matching lines @@
   this.visit(node.body);
   this.expectedReturnType = previous;
   return functionType;
 }
 TypeCheckerVisitor.prototype.visitIdentifier = function(node) {
   this.fail(node);
 }
 TypeCheckerVisitor.prototype.visitSend = function(node) {
   var target = this.elements.$index(node);
   if (target != null) {
-    var funType = target.type;
+    var funType = target.computeType(this.compiler, this.types);
     var formals = funType.parameterTypes;
     var arguments = node.get$arguments();
     while ((!formals.isEmpty()) && (!arguments.isEmpty())) {
       this.compiler.cancel('parameters not supported.');
       var argumentType = this.visit(arguments.get$head());
       if (!this.types.isAssignable(formals.get$head(), argumentType)) {
         var warning = CompilerError.NOT_ASSIGNABLE(argumentType, formals.get$head());
         this.compiler.reportWarning(node, warning);
       }
       formals = formals.get$tail();
@@ skipping 9897 matching lines @@
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 main();