Small fixes in preparation for SemanticVisitor.

pkg/compiler/lib/src/typechecker.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.
 
 part of dart2js;
 
 class TypeCheckerTask extends CompilerTask {
   TypeCheckerTask(Compiler compiler) : super(compiler);
   String get name => "Type checker";
 
@@ skipping 29 matching lines @@
   String toString() => name;
 }
 
 /**
  * [ElementAccess] represents the access of [element], either as a property
  * access or invocation.
  */
 abstract class ElementAccess {
   Element get element;
 
+  String get name => element.name;
+
   DartType computeType(Compiler compiler);
 
   /// Returns [: true :] if the element can be access as an invocation.
   bool isCallable(Compiler compiler) {
     if (element != null && element.isAbstractField) {
       AbstractFieldElement abstractFieldElement = element;
       if (abstractFieldElement.getter == null) {
         // Setters cannot be invoked as function invocations.
         return false;
       }
@@ skipping 15 matching lines @@
 
   String toString() => 'MemberAccess($member)';
 }
 
 /// An access of an unresolved element.
 class DynamicAccess implements ElementAccess {
   const DynamicAccess();
 
   Element get element => null;
 
+  String get name => 'dynamic';
+
   DartType computeType(Compiler compiler) => const DynamicType();
 
   bool isCallable(Compiler compiler) => true;
 
   String toString() => 'DynamicAccess';
 }
 
 /// An access of the `assert` method.
 class AssertAccess implements ElementAccess {
   const AssertAccess();
 
   Element get element => null;
 
+  String get name => 'assert';
+
   DartType computeType(Compiler compiler) {
     return new FunctionType.synthesized(
         const VoidType(),
         <DartType>[const DynamicType()]);
   }
 
   bool isCallable(Compiler compiler) => true;
 
   String toString() => 'AssertAccess';
 }
@@ skipping 66 matching lines @@
  */
 class TypeLiteralAccess extends ElementAccess {
   final DartType type;
 
   TypeLiteralAccess(this.type) {
     assert(type != null);
   }
 
   Element get element => type.element;
 
+  String get name => type.name;
+
   DartType computeType(Compiler compiler) => compiler.typeClass.rawType;
 
   String toString() => 'TypeLiteralAccess($type)';
 }
 
 
 /// An access to the 'call' method of a function type.
 class FunctionCallAccess implements ElementAccess {
   final Element element;
   final DartType type;
 
   const FunctionCallAccess(this.element, this.type);
 
+  String get name => 'call';
+
   DartType computeType(Compiler compiler) => type;
 
   bool isCallable(Compiler compiler) => true;
 
   String toString() => 'FunctionAccess($element, $type)';
 }
 
 
 /// An is-expression that potentially promotes a variable.
 class TypePromotion {
@@ skipping 717 matching lines @@
   //
   // If provided [argumentTypes] is filled with the argument types during
   // analysis.
   DartType analyzeInvocation(Send node, ElementAccess elementAccess,
                              [LinkBuilder<DartType> argumentTypes]) {
     DartType type = elementAccess.computeType(compiler);
     if (elementAccess.isCallable(compiler)) {
       analyzeArguments(node, elementAccess.element, type, argumentTypes);
     } else {
       reportTypeWarning(node, MessageKind.NOT_CALLABLE,
-          {'elementName': elementAccess.element.name});
+          {'elementName': elementAccess.name});
       analyzeArguments(node, elementAccess.element, const DynamicType(),
                        argumentTypes);
     }
     type = type.unalias(compiler);
     if (identical(type.kind, TypeKind.FUNCTION)) {
       FunctionType funType = type;
       return funType.returnType;
     } else {
       return const DynamicType();
     }
@@ skipping 899 matching lines @@
 
   visitTypedef(Typedef node) {
     // Do not typecheck [Typedef] nodes.
   }
 
   visitNode(Node node) {
     compiler.internalError(node,
         'Unexpected node ${node.getObjectDescription()} in the type checker.');
   }
 }