Add element to qualifier name for code completion

compiler/java/com/google/dart/compiler/resolver/Resolver.java

 // 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.
 
 package com.google.dart.compiler.resolver;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 import com.google.dart.compiler.DartCompilationPhase;
@@ skipping 1113 matching lines @@
           element = scope.findElement(scope.getLibrary(), x.getPropertyName());
           if (element == null) {
             onError(x, ResolverErrorCode.CANNOT_BE_RESOLVED_LIBRARY,
                 x.getPropertyName(), qualifier.getName());
           }
           break;
 
         default:
           break;
       }
+      if (x.getName() != null) {
+        recordElement(x.getName(), element);
+      }
       return recordElement(x, element);
     }
 
     private Element resolveQualifier(DartNode qualifier) {
       return (qualifier instanceof DartIdentifier)
           ? resolveIdentifier((DartIdentifier) qualifier, true)
           : qualifier.accept(this);
     }
 
     @Override
     public Element visitMethodInvocation(DartMethodInvocation x) {
       Element target = resolveQualifier(x.getTarget());
       Element element = null;
 
       switch (ElementKind.of(target)) {
         case CLASS: {
           // Must be a static method or field.
           ClassElement classElement = (ClassElement) target;
           element = Elements.lookupLocalMethod(classElement, x.getFunctionNameString());
           if (element == null) {
             element = Elements.lookupLocalField(classElement, x.getFunctionNameString());
           }
           if (element == null || !element.getModifiers().isStatic()) {
-            diagnoseErrorInMethodInvocation(x, (ClassElement) target, element);
+            diagnoseErrorInMethodInvocation(x, classElement, element);
           }
           break;
         }
 
         case SUPER: {
           // Must be a superclass' method or field.
           ClassElement classElement = ((SuperElement) target).getClassElement();
           InterfaceType type = classElement.getType();
           Member member = type.lookupMember(x.getFunctionNameString());
           if (member != null) {
             if (!member.getElement().getModifiers().isStatic()) {
               element = member.getElement();
             }
           }
           break;
         }
 
         case LIBRARY:
           // Library prefix, lookup the element in the reference library.
           LibraryElement library = ((LibraryElement) target);
           element = library.getScope().findElement(context.getScope().getLibrary(),
                                                    x.getFunctionNameString());
           if (element == null) {
-            diagnoseErrorInMethodInvocation(x, null, null);
+            diagnoseErrorInMethodInvocation(x, library, null);
           } else {
             x.getFunctionName().setElement(element);
           }
           break;
       }
 
       checkInvocationTarget(x, currentMethod, target);
       visit(x.getArguments());
       return recordElement(x, element);
     }
@@ skipping 185 matching lines @@
         onError(x.getLabel(), ResolverErrorCode.CANNOT_RESOLVE_LABEL,
             x.getTargetName());
       } else if (ElementKind.of(element).equals(ElementKind.LABEL)) {
         onError(x.getLabel(), ResolverErrorCode.CANNOT_ACCESS_OUTER_LABEL,
             x.getTargetName());
       } else {
         onError(x.getLabel(), ResolverErrorCode.NOT_A_LABEL, x.getTargetName());
       }
     }
 
-    private void diagnoseErrorInMethodInvocation(DartMethodInvocation node, ClassElement klass,
+    private void diagnoseErrorInMethodInvocation(DartMethodInvocation node, Element classOrLibrary,
                                                  Element element) {
       String name = node.getFunctionNameString();
       ElementKind kind = ElementKind.of(element);
       DartNode errorNode = node.getFunctionName();
       switch (kind) {
         case NONE:
-          onError(errorNode, ResolverErrorCode.CANNOT_RESOLVE_METHOD, name);
+          switch (ElementKind.of(classOrLibrary)) {
+            case CLASS:
+              onError(errorNode, ResolverErrorCode.CANNOT_RESOLVE_METHOD_IN_CLASS, name, 
+                      classOrLibrary.getName());
+              break;
+            case LIBRARY:
+              onError(errorNode, ResolverErrorCode.CANNOT_RESOLVE_METHOD_IN_LIBRARY, name, 
+                      classOrLibrary.getName());
+              break;              
+            default:
+              onError(errorNode, ResolverErrorCode.CANNOT_RESOLVE_METHOD, name);
+          }
+          
           break;
 
         case CONSTRUCTOR:
-          onError(errorNode, ResolverErrorCode.IS_A_CONSTRUCTOR, klass.getName(),
+          onError(errorNode, ResolverErrorCode.IS_A_CONSTRUCTOR, classOrLibrary.getName(),
                           name);
           break;
 
         case METHOD: {
           assert !((MethodElement) element).getModifiers().isStatic();
           onError(errorNode, ResolverErrorCode.IS_AN_INSTANCE_METHOD,
-              klass.getName(), name);
+              classOrLibrary.getName(), name);
           break;
         }
 
         default:
           throw context.internalError(errorNode, "Unexpected kind of element: %s", kind);
       }
     }
 
     private void diagnoseErrorInUnqualifiedInvocation(DartUnqualifiedInvocation node) {
       String name = node.getTarget().getName();
@@ skipping 452 matching lines @@
         ClassElement nextClass = (ClassElement) nextConstructorElement.getEnclosingElement();
         ClassElement currentClass = (ClassElement) constructor.getEnclosingElement();
         if (nextClass == currentClass) {
           return (ConstructorNodeElement) nextConstructorElement;
         }
       }
     }
     return null;
   }
 }