Move computeType to TypedElement and TypeDeclarationElement.

pkg/compiler/lib/src/resolution/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.
 
 part of resolution;
 
 /**
  * Core implementation of resolution.
  *
  * Do not subclass or instantiate this class outside this library
@@ skipping 741 matching lines @@
     // type literal.
     DartType type;
 
     // TODO(johnniwinther): Remove this hack when we can pass more complex
     // information between methods than resolved elements.
     if (target == compiler.typeClass && node.receiver == null) {
       // Potentially a 'dynamic' type literal.
       type = registry.getType(node.selector);
     }
     if (type == null) {
-      type = target.computeType(compiler);
+      if (target.isTypedef || target.isClass) {
+        TypeDeclarationElement typeDeclaration = target;
+        typeDeclaration.computeType(compiler);
+        type = typeDeclaration.rawType;
+      } else {
+        TypeVariableElement typeVariable = target;
+        type = typeVariable.type;
+      }
     }
     registry.registerTypeLiteral(node, type);
 
     if (!target.isTypeVariable) {
       // Don't try to make constants of calls and assignments to type literals.
       if (!node.isCall && node.asSendSet() == null) {
         analyzeConstantDeferred(node, enforceConst: false);
       } else {
         // The node itself is not a constant but we register the selector (the
         // identifier that refers to the class/typedef) as a constant.
@@ skipping 939 matching lines @@
     registerPotentialAccessInClosure(node, element);
 
     return node.isPropertyAccess
         ? new ElementResult(element) : const NoneResult();
   }
 
   /// Handle access of a static or top level [element].
   ResolutionResult handleStaticOrTopLevelAccess(
         Send node, Name name, Element element) {
 
+    MemberElement member;
     if (element.isAbstractField) {
       AbstractFieldElement abstractField = element;
       if (abstractField.getter != null) {
-        element = abstractField.getter;
+        member = abstractField.getter;
       } else {
-        element = abstractField.setter;
+        member = abstractField.setter;
       }
+    } else {
+      member = element;
     }
     // TODO(johnniwinther): Needed to provoke a parsing and with it discovery
     // of parse errors to make [element] erroneous. Fix this!
-    element.computeType(compiler);
+    member.computeType(compiler);
 
     Selector selector;
     CallStructure callStructure = CallStructure.NO_ARGS;
     if (node.isCall) {
       callStructure = resolveArguments(node.argumentsNode);
       selector = new Selector(SelectorKind.CALL, name, callStructure);
     } else {
       selector = new Selector(SelectorKind.GETTER, name, callStructure);
     }
     AccessSemantics semantics =
-        computeStaticOrTopLevelAccessSemantics(node, element);
+        computeStaticOrTopLevelAccessSemantics(node, member);
     if (node.isCall) {
       bool isIncompatibleInvoke = false;
       switch (semantics.kind) {
         case AccessKind.STATIC_METHOD:
         case AccessKind.TOPLEVEL_METHOD:
           MethodElementX method = semantics.element;
           method.computeSignature(compiler);
           if (!callStructure.signatureApplies(method)) {
             registry.registerThrowNoSuchMethod();
             registry.registerDynamicInvocation(selector);
@@ skipping 10 matching lines @@
         case AccessKind.FINAL_TOPLEVEL_FIELD:
         case AccessKind.TOPLEVEL_GETTER:
           registry.registerStaticUse(semantics.element);
           selector = callStructure.callSelector;
           registry.registerDynamicInvocation(selector);
           break;
         case AccessKind.STATIC_SETTER:
         case AccessKind.TOPLEVEL_SETTER:
         case AccessKind.UNRESOLVED:
           registry.registerThrowNoSuchMethod();
-          element = reportAndCreateErroneousElement(
+          member = reportAndCreateErroneousElement(
               node.selector, name.text,
               MessageKind.CANNOT_RESOLVE_GETTER, const {});
           break;
         default:
           internalError(node,
               "Unexpected statically resolved access $semantics.");
           break;
       }
       registry.registerSendStructure(node,
           isIncompatibleInvoke
@@ skipping 13 matching lines @@
         case AccessKind.STATIC_GETTER:
         case AccessKind.TOPLEVEL_FIELD:
         case AccessKind.FINAL_TOPLEVEL_FIELD:
         case AccessKind.TOPLEVEL_GETTER:
           registry.registerStaticUse(semantics.element);
           break;
         case AccessKind.STATIC_SETTER:
         case AccessKind.TOPLEVEL_SETTER:
         case AccessKind.UNRESOLVED:
           registry.registerThrowNoSuchMethod();
-          element = reportAndCreateErroneousElement(
+          member = reportAndCreateErroneousElement(
               node.selector, name.text,
               MessageKind.CANNOT_RESOLVE_GETTER, const {});
           break;
         default:
           internalError(node,
               "Unexpected statically resolved access $semantics.");
           break;
       }
       registry.registerSendStructure(node,
           new GetStructure(semantics, selector));
     }
 
     // TODO(johnniwinther): Remove these when all information goes through
     // the [SendStructure].
-    registry.useElement(node, element);
+    registry.useElement(node, member);
     registry.setSelector(node, selector);
 
     return node.isPropertyAccess
-        ? new ElementResult(element) : const NoneResult();
+        ? new ElementResult(member) : const NoneResult();
   }
 
   /// Handle access to resolved [element].
   ResolutionResult handleResolvedSend(Send node, Name name, Element element) {
     if (element.isAmbiguous) {
       return handleAmbiguousSend(node, name, element);
     }
     if (element.isErroneous) {
       // This handles elements with parser errors.
       // TODO(johnniwinther): Elements with parse error should not set
@@ skipping 1427 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }