Run co19 language tests on leg.

dart/frog/leg/resolver.dart

 // Copyright (c) 2012, 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.
 
 interface TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
 }
 
 class TreeElementMapping implements TreeElements {
@@ skipping 704 matching lines @@
   visitLiteralNull(LiteralNull node) {
   }
 
   visitNodeList(NodeList node) {
     for (Link<Node> link = node.nodes; !link.isEmpty(); link = link.tail) {
       visit(link.head);
     }
   }
 
   visitOperator(Operator node) {
-    cancel(node, "Unimplemented");
+    compiler.unimplemented('operator', node: node);
   }
 
   visitReturn(Return node) {
     visit(node.expression);
   }
 
   visitThrow(Throw node) {
     visit(node.expression);
   }
 
@@ skipping 63 matching lines @@
   ClassElement resolveTypeRequired(Node node) {
     bool old = typeRequired;
     typeRequired = true;
     ClassElement cls = visit(node);
     typeRequired = old;
     return cls;
   }
 
   visitModifiers(Modifiers node) {
     // TODO(ngeoffray): Implement this.
-    cancel(node, 'unimplemented');
+    compiler.unimplemented('modifiers', node: node);
   }
 
   visitLiteralList(LiteralList node) {
     if (node.isConst()) cancel(node, 'const literal lists are not implemented');
     visit(node.elements);
   }
 
   visitConditional(Conditional node) {
     node.visitChildren(this);
   }
 
   visitStringInterpolation(StringInterpolation node) {
     node.visitChildren(this);
   }
 
   visitStringInterpolationPart(StringInterpolationPart node) {
     node.visitChildren(this);
   }
 
   visitBreakStatement(BreakStatement node) {
-    cancel(node, 'unimplemented');
+    compiler.unimplemented('break', node: node);
   }
 
   visitContinueStatement(ContinueStatement node) {
-    cancel(node, 'unimplemented');
+    compiler.unimplemented('continue', node: node);
   }
 
   visitForInStatement(ForInStatement node) {
     visit(node.expression);
     Scope scope = new BlockScope(context);
     Node declaration = node.declaredIdentifier;
     visitIn(declaration, scope);
     visitIn(node.body, scope);
     // TODO(lrn): Also allow a single identifier.
     if ((declaration is !Send || declaration.asSend().selector is !Identifier)
         && (declaration is !VariableDefinitions ||
         !declaration.asVariableDefinitions().definitions.nodes.tail.isEmpty()))
     {
       // The variable declaration is either not an identifier, not a
       // declaration, or it's declaring more than one variable.
       error(node.declaredIdentifier, MessageKind.INVALID_FOR_IN, []);
     }
   }
 
   visitLabelledStatement(LabelledStatement node) {
-    cancel(node, 'unimplemented');
+    compiler.unimplemented('label', node: node);
   }
 
   visitLiteralMap(LiteralMap node) {
-    cancel(node, 'unimplemented');
+    compiler.unimplemented('map', node: node);
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
-    cancel(node, 'unimplemented');
+    compiler.unimplemented('map entry', node: node);
   }
 
   visitNamedArgument(NamedArgument node) {
     visit(node.expression);
   }
 
   visitSwitchStatement(SwitchStatement node) {
-    cancel(node, 'unimplemented');
+    compiler.unimplemented('switch', node: node);
   }
 
   visitTryStatement(TryStatement node) {
-    cancel(node, 'unimplemented');
-  }
-
-  visitScriptTag(ScriptTag node) {
-    cancel(node, 'unimplemented');
+    compiler.unimplemented('try', node: node);
   }
 
   visitCatchBlock(CatchBlock node) {
-    cancel(node, 'unimplemented');
+    compiler.unimplemented('catch', node: node);
   }
 
   visitTypedef(Typedef node) {
-    cancel(node, 'unimplemented');
+    compiler.unimplemented('typedef', node: node);
   }
 }
 
 // TODO(ahe): Frog cannot handle generic types.
 class ClassResolverVisitor extends AbstractVisitor/* <Type> */ {
   Compiler compiler;
   Scope context;
 
   ClassResolverVisitor(Compiler compiler, LibraryElement library)
     : this.compiler = compiler, context = new TopScope(library);
@@ skipping 276 matching lines @@
 class TopScope extends Scope {
   LibraryElement get library() => element;
 
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) => library.find(name);
 
   Element add(Element element) {
     throw "Cannot add an element in the top scope";
   }
 }