Address review comments.

frog/leg/resolver.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.
 
 interface TreeElements {
   Element operator[](Node node);
 }
 
 class TreeElementMapping implements TreeElements {
   Map<Node, Element> map;
@@ skipping 620 matching lines @@
   }
 
   visitParenthesizedExpression(ParenthesizedExpression node) {
     visit(node.expression);
   }
 
   visitNewExpression(NewExpression node) {
     if (node.isConst()) cancel(node, 'const expressions are not implemented');
     if (node.send.selector.asTypeAnnotation() === null) {
       cancel(
-          node, 'named constructors with type parameters are not implemented');
+          node, 'named constructors with type arguments are not implemented');
     }
 
     visit(node.send.argumentsNode);
 
     SourceString constructorName;
     Node typeName = node.send.selector.asTypeAnnotation().typeName;
     if (typeName.asSend() !== null) {
       Identifier receiver = typeName.asSend().receiver.asIdentifier();
       Identifier selector = typeName.asSend().selector.asIdentifier();
       SourceString className = receiver.source;
@@ skipping 212 matching lines @@
       if (name !== null) {
         VariableElement element = new VariableElement(
             name, variables, kind, resolver.context.element, node: link.head);
         resolver.defineElement(link.head, element);
       }
     }
   }
 
   visit(Node node) => node.accept(this);
 
-  visitSend(Node node) {
+  visitSend(Send node) {
     // The lhs is a property access. The parser never accepts this
     // code right now if it's not a field initializer.
     if (kind !== ElementKind.PARAMETER || node.receiver === null) {
-      resolver.cancel('internal error');
+      resolver.cancel(node, 'internal error');
     }
 
-    if (resolver.element.kind !== ElementKind.GENERATIVE_CONSTRUCTOR) {
+    if (node.receiver.asIdentifier() === null ||
+        !node.receiver.asIdentifier().isThis()) {
+      resolver.error(node, MessageKind.INVALID_PARAMETER, []);
+    } else if (resolver.enclosingElement.kind !==
+                  ElementKind.GENERATIVE_CONSTRUCTOR) {
       resolver.error(node, MessageKind.FIELD_PARAMETER_NOT_ALLOWED, []);
-    } else if (node.receiver.asIdentifier() === null ||
-               !node.receiver.asIdentifier().isThis()) {
-      resolver.error(node, MessageKind.INVALID_FIELD_PARAMETER, []);
     } else {
       SourceString name = node.selector.asIdentifier().source;
       Element field = resolver.currentClass.lookupLocalMember(name);
       if (field.kind !== ElementKind.FIELD) {
         resolver.error(node, MessageKind.NOT_A_FIELD, [name]);
       } else if (!field.isInstanceMember()) {
         resolver.error(node, MessageKind.NOT_INSTANCE_FIELD, [name]);
-      } else {
-        resolver.defineElement(node, field);
       }
+      resolver.defineElement(node, field);
     }
     return null;
   }
 
   visitNode(Node node) {
     resolver.cancel(node, 'not implemented');
   }
 }
 
 // TODO(ahe): Frog cannot handle generic types.
@@ skipping 93 matching lines @@
 class TopScope extends Scope {
   Universe universe;
 
   TopScope(Universe this.universe) : super(null, null);
   Element lookup(SourceString name) => universe.find(name);
 
   Element add(Element element) {
     throw "Cannot add an element in the top scope";
   }
 }