Handle resolution of Class.named<TypeArg> correctly.

sdk/lib/_internal/compiler/implementation/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;
 
 abstract class TreeElements {
   Element get currentElement;
   Setlet<Node> get superUses;
 
@@ skipping 1609 matching lines @@
 
 class TypeResolver {
   final Compiler compiler;
 
   TypeResolver(this.compiler);
 
   Element resolveTypeName(Scope scope,
                           Identifier prefixName,
                           Identifier typeName) {
     if (prefixName != null) {
-      Element e = lookupInScope(compiler, prefixName, scope, prefixName.source);
-      if (e != null) {
-        if (identical(e.kind, ElementKind.PREFIX)) {
-          // The receiver is a prefix. Lookup in the imported members.
-          PrefixElement prefix = e;
-          return prefix.lookupLocalMember(typeName.source);
-        } else if (identical(e.kind, ElementKind.CLASS)) {
-          // TODO(johnniwinther): Remove this case.
-          // The receiver is the class part of a named constructor.
-          return e;
-        }
-      } else {
-        // The caller creates the ErroneousElement for the MalformedType.
-        return null;
+      Element element =
+          lookupInScope(compiler, prefixName, scope, prefixName.source);
+      if (element != null && element.isPrefix()) {
+        // The receiver is a prefix. Lookup in the imported members.
+        PrefixElement prefix = element;
+        return prefix.lookupLocalMember(typeName.source);
       }
+      // The caller of this method will create the ErroneousElement for
+      // the MalformedType.
+      return null;
     } else {
       String stringValue = typeName.source;
       if (identical(stringValue, 'void')) {
         return compiler.types.voidType.element;
       } else if (identical(stringValue, 'dynamic')) {
         return compiler.dynamicClass;
       } else {
         return lookupInScope(compiler, typeName, scope, typeName.source);
       }
     }
   }
 
   DartType resolveTypeAnnotation(MappingVisitor visitor, TypeAnnotation node,
                                  {bool malformedIsError: false}) {
     Identifier typeName;
     Identifier prefixName;
     Send send = node.typeName.asSend();
     if (send != null) {
       // The type name is of the form [: prefix . identifier :].
       prefixName = send.receiver.asIdentifier();
       typeName = send.selector.asIdentifier();
     } else {
       typeName = node.typeName.asIdentifier();
     }
 
     Element element = resolveTypeName(visitor.scope, prefixName, typeName);
-    DartType type;
 
     DartType reportFailureAndCreateType(DualKind messageKind,
                                         Map messageArguments,
                                         {DartType userProvidedBadType}) {
       if (malformedIsError) {
         visitor.error(node, messageKind.error, messageArguments);
       } else {
         compiler.backend.registerThrowRuntimeError(visitor.mapping);
         visitor.warning(node, messageKind.warning, messageArguments);
       }
@@ skipping 12 matching lines @@
           visitor, node, const Link<DartType>(), arguments);
       if (hasTypeArgumentMismatch) {
         return new MalformedType(
             new ErroneousElementX(MessageKind.TYPE_ARGUMENT_COUNT_MISMATCH,
                 {'type': node}, typeName.source, visitor.enclosingElement),
                 type, arguments.toLink());
       }
       return type;
     }
 
+    DartType type;
     if (element == null) {
       type = reportFailureAndCreateType(
           MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': node.typeName});
     } else if (element.isAmbiguous()) {
       AmbiguousElement ambiguous = element;
       type = reportFailureAndCreateType(
           ambiguous.messageKind, ambiguous.messageArguments);
       ambiguous.diagnose(visitor.mapping.currentElement, compiler);
     } else if (!element.impliesType()) {
       type = reportFailureAndCreateType(
@@ skipping 2961 matching lines @@
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }
 
 /// 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);
 }