Fix issue 19424

editor/tools/plugins/com.google.dart.engine/src/com/google/dart/engine/internal/resolver/ElementResolver.java

 /*
  * Copyright (c) 2013, the Dart project authors.
  * 
  * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
  * in compliance with the License. You may obtain a copy of the License at
  * 
  * http://www.eclipse.org/legal/epl-v10.html
  * 
  * Unless required by applicable law or agreed to in writing, software distributed under the License
  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
@@ skipping 177 matching lines @@
    * no identifier in the AST when the parser could not distinguish between a method invocation and
    * an invocation of a top-level function imported with a prefix.
    */
   private static class SyntheticIdentifier extends Identifier {
     /**
      * The name of the synthetic identifier.
      */
     private final String name;
 
     /**
+     * The identifier to be highlighted in case of an error
+     */
+    private final Identifier identifier;

[Paul Berry, 2014/11/04 23:07:41]

Nit: although the comment makes it clear what this field is for, the name
doesn't, and I'm worried it could lead to confusion in places where this is
used.  How about renaming to something like "errorTarget"?

[Brian Wilkerson, 2014/11/05 17:05:25]

I renamed it.

+
+    /**
      * Initialize a newly created synthetic identifier to have the given name.
      * 
      * @param name the name of the synthetic identifier
+     * @param identifier the identifier to be highlighted in case of an error
      */
-    private SyntheticIdentifier(String name) {
+    private SyntheticIdentifier(String name, Identifier identifier) {
       this.name = name;
+      this.identifier = identifier;
     }
 
     @Override
     public <R> R accept(AstVisitor<R> visitor) {
       return null;
     }
 
     @Override
     public Token getBeginToken() {
       return null;
     }
 
     @Override
     public Element getBestElement() {
       return null;
     }
 
     @Override
     public Token getEndToken() {
       return null;
     }
 
     @Override
+    public int getLength() {
+      return identifier.getLength();
+    }
+
+    @Override
     public String getName() {
       return name;
     }
 
     @Override
+    public int getOffset() {
+      return identifier.getOffset();
+    }
+
+    @Override
     public int getPrecedence() {
       return 16;
     }
 
     @Override
     public Element getPropagatedElement() {
       return null;
     }
 
     @Override
@@ skipping 927 matching lines @@
       return null;
     }
     //
     // Check to see whether the prefix is really a prefix.
     //
     Element prefixElement = prefix.getStaticElement();
     if (prefixElement instanceof PrefixElement) {
       Element element = resolver.getNameScope().lookup(node, definingLibrary);
       if (element == null && identifier.inSetterContext()) {
         element = resolver.getNameScope().lookup(
-            new SyntheticIdentifier(node.getName() + "="),
+            new SyntheticIdentifier(node.getName() + "=", node),
             definingLibrary);
       }
       if (element == null) {
         if (identifier.inSetterContext()) {
           resolver.reportErrorForNode(
               StaticWarningCode.UNDEFINED_SETTER,
               identifier,
               identifier.getName(),
               prefixElement.getName());
         } else if (node.getParent() instanceof Annotation) {
@@ skipping 513 matching lines @@
    * @param identifier the identifier that might have been imported using a prefix
    * @return the element that was found
    */
   private Element findImportWithoutPrefix(SimpleIdentifier identifier) {
     Element element = null;
     Scope nameScope = resolver.getNameScope();
     for (ImportElement importElement : definingLibrary.getImports()) {
       PrefixElement prefixElement = importElement.getPrefix();
       if (prefixElement != null) {
         Identifier prefixedIdentifier = new SyntheticIdentifier(prefixElement.getName() + "."
-            + identifier.getName());
+            + identifier.getName(), identifier);
         Element importedElement = nameScope.lookup(prefixedIdentifier, definingLibrary);
         if (importedElement != null) {
           if (element == null) {
             element = importedElement;
           } else {
             element = MultiplyDefinedElementImpl.fromElements(
                 definingLibrary.getContext(),
                 element,
                 importedElement);
           }
@@ skipping 1089 matching lines @@
       Element element = lookUpMethod(target, targetType, methodName.getName());
       if (element == null) {
         //
         // If there's no method, then it's possible that 'm' is a getter that returns a function.
         //
         // TODO (collinsn): need to add union type support here too, in the style of [lookUpMethod].
         element = lookUpGetter(target, targetType, methodName.getName());
       }
       return element;
     } else if (target instanceof SimpleIdentifier) {
-      Element targetElement = ((SimpleIdentifier) target).getStaticElement();
+      SimpleIdentifier identifier = (SimpleIdentifier) target;
+      Element targetElement = identifier.getStaticElement();
       if (targetElement instanceof PrefixElement) {
         //
         // Look to see whether the name of the method is really part of a prefixed identifier for an
         // imported top-level function or top-level getter that returns a function.
         //
-        final String name = ((SimpleIdentifier) target).getName() + "." + methodName;
-        Identifier functionName = new SyntheticIdentifier(name);
+        final String name = identifier.getName() + "." + methodName;
+        Identifier functionName = new SyntheticIdentifier(name, methodName);
         Element element = resolver.getNameScope().lookup(functionName, definingLibrary);
         if (element != null) {
           // TODO(brianwilkerson) This isn't a method invocation, it's a function invocation where
           // the function name is a prefixed identifier. Consider re-writing the AST.
           return element;
         }
       }
     }
     // TODO(brianwilkerson) Report this error.
     return null;
@@ skipping 153 matching lines @@
             setter = lookUpSetter(null, enclosingClass.getType(), node.getName());
           }
         }
         if (setter != null) {
           element = setter;
         }
       }
     } else if (element == null
         && (node.inSetterContext() || node.getParent() instanceof CommentReference)) {
       element = resolver.getNameScope().lookup(
-          new SyntheticIdentifier(node.getName() + "="),
+          new SyntheticIdentifier(node.getName() + "=", node),
           definingLibrary);
     }
     ClassElement enclosingClass = resolver.getEnclosingClass();
     if (element == null && enclosingClass != null) {
       InterfaceType enclosingType = enclosingClass.getType();
       if (element == null
           && (node.inSetterContext() || node.getParent() instanceof CommentReference)) {
         element = lookUpSetter(null, enclosingType, node.getName());
       }
       if (element == null && node.inGetterContext()) {
@@ skipping 82 matching lines @@
    * @param member the result of the look-up
    * @return {@code true} if we should report an error
    */
   private boolean shouldReportMissingMember(Type type, Element member) {
     if (member != null || type == null || type.isDynamic() || type.isBottom()) {
       return false;
     }
     return true;
   }
 }