Add Resolution and Parsing interfaces for computeType, ensureResolved and parseNode.

pkg/compiler/lib/src/resolution/class_members.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.
 
 library dart2js.resolution.compute_members;
 
 import '../common/names.dart' show
     Identifiers;
+import '../common/resolution.dart' show
+    Resolution;
 import '../compiler.dart' show
     Compiler;
 import '../dart_types.dart';
 import '../diagnostics/diagnostic_listener.dart' show
     DiagnosticMessage;
 import '../diagnostics/invariant.dart' show
     invariant;
 import '../diagnostics/messages.dart' show
     MessageKind;
 import '../elements/elements.dart' show
@@ skipping 21 matching lines @@
       new Map<dynamic, Set<MessageKind>>();
 
   MembersCreator(Compiler this.compiler,
                  ClassElement this.cls,
                  Iterable<String> this.computedMemberNames,
                  Map<Name, Member> this.classMembers) {
     assert(invariant(cls, cls.isDeclaration,
         message: "Members may only be computed on declarations."));
   }
 
+  Resolution get resolution => compiler.resolution;
+
   void reportMessage(var marker, MessageKind kind, report()) {
     Set<MessageKind> messages =
         reportedMessages.putIfAbsent(marker,
             () => new Set<MessageKind>());
     if (messages.add(kind)) {
       report();
     }
   }
 
   bool shouldSkipMember(MemberSignature member) {
@@ skipping 127 matching lines @@
             declared =
                 new DeclaredMember(name, element, thisType, type, functionType);
           }
           declaredMembers[name] = declared;
           classMembers[name] = declared;
           checkValidOverride(declared, inherited);
         }
 
         Name name = new Name(element.name, library);
         if (element.isField) {
-          DartType type = element.computeType(compiler);
+          DartType type = element.computeType(resolution);
           addDeclaredMember(name, type, new FunctionType.synthesized(type));
           if (!element.isConst && !element.isFinal) {
             addDeclaredMember(name.setter, type,
                 new FunctionType.synthesized(
                                  const VoidType(),
                                  <DartType>[type]));
           }
         } else if (element.isGetter) {
-          FunctionType functionType = element.computeType(compiler);
+          FunctionType functionType = element.computeType(resolution);
           DartType type = functionType.returnType;
           addDeclaredMember(name, type, functionType);
         } else if (element.isSetter) {
-          FunctionType functionType = element.computeType(compiler);
+          FunctionType functionType = element.computeType(resolution);
           DartType type;
           if (!functionType.parameterTypes.isEmpty) {
             type = functionType.parameterTypes.first;
           } else {
             type = const DynamicType();
           }
           name = name.setter;
           addDeclaredMember(name, type, functionType);
         } else {
           assert(invariant(element, element.isFunction));
-          FunctionType type = element.computeType(compiler);
+          FunctionType type = element.computeType(resolution);
           addDeclaredMember(name, type, type);
         }
       }
 
       cls.forEachLocalMember(createMember);
       if (cls.isPatched) {
         cls.implementation.forEachLocalMember((Element element) {
           if (element.isDeclaration) {
             createMember(element);
           }
@@ skipping 713 matching lines @@
         message: "Members have not been fully computed for $this."));
     if (interfaceMembersAreClassMembers) {
       classMembers.forEach((_, member) {
         if (!member.isStatic) f(member);
       });
     } else {
       interfaceMembers.forEach((_, member) => f(member));
     }
   }
 }