Fix issue 19424

pkg/analyzer/lib/src/generated/element_resolver.dart

 // Copyright (c) 2014, 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 engine.resolver.element_resolver;
 
 import 'dart:collection';
 
 import 'error.dart';
 import 'scanner.dart' as sc;
@@ skipping 850 matching lines @@
       identifier.staticElement = importedLibrary.loadLibraryFunction;
       return null;
     }
     //
     // Check to see whether the prefix is really a prefix.
     //
     Element prefixElement = prefix.staticElement;
     if (prefixElement is PrefixElement) {
       Element element = _resolver.nameScope.lookup(node, _definingLibrary);
       if (element == null && identifier.inSetterContext()) {
-        element = _resolver.nameScope.lookup(new ElementResolver_SyntheticIdentifier("${node.name}="), _definingLibrary);
+        element = _resolver.nameScope.lookup(new SyntheticIdentifier(
+            "${node.name}=", node),
+            _definingLibrary);
       }
       if (element == null) {
         if (identifier.inSetterContext()) {
           _resolver.reportErrorForNode(StaticWarningCode.UNDEFINED_SETTER, identifier, [identifier.name, prefixElement.name]);
         } else if (node.parent is Annotation) {
           Annotation annotation = node.parent as Annotation;
           _resolver.reportErrorForNode(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
           return null;
         } else {
           _resolver.reportErrorForNode(StaticWarningCode.UNDEFINED_GETTER, identifier, [identifier.name, prefixElement.name]);
@@ skipping 440 matching lines @@
    *
    * @param identifier the identifier that might have been imported using a prefix
    * @return the element that was found
    */
   Element _findImportWithoutPrefix(SimpleIdentifier identifier) {
     Element element = null;
     Scope nameScope = _resolver.nameScope;
     for (ImportElement importElement in _definingLibrary.imports) {
       PrefixElement prefixElement = importElement.prefix;
       if (prefixElement != null) {
-        Identifier prefixedIdentifier = new ElementResolver_SyntheticIdentifier("${prefixElement.name}.${identifier.name}");
+        Identifier prefixedIdentifier = new SyntheticIdentifier(
+            "${prefixElement.name}.${identifier.name}",
+            identifier);
         Element importedElement = nameScope.lookup(prefixedIdentifier, _definingLibrary);
         if (importedElement != null) {
           if (element == null) {
             element = importedElement;
           } else {
             element = MultiplyDefinedElementImpl.fromElements(_definingLibrary.context, element, importedElement);
           }
         }
       }
     }
@@ skipping 1005 matching lines @@
       }
       return element;
     } else if (target is SimpleIdentifier) {
       Element targetElement = target.staticElement;
       if (targetElement is 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.
         //
         String name = "${target.name}.$methodName";
-        Identifier functionName = new ElementResolver_SyntheticIdentifier(name);
+        Identifier functionName = new SyntheticIdentifier(name, methodName);
         Element element = _resolver.nameScope.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 111 matching lines @@
           //
           ClassElement enclosingClass = _resolver.enclosingClass;
           if (enclosingClass != null) {
             setter = _lookUpSetter(null, enclosingClass.type, node.name);
           }
         }
         if (setter != null) {
           element = setter;
         }
       }
-    } else if (element == null && (node.inSetterContext() || node.parent is CommentReference)) {
-      element = _resolver.nameScope.lookup(new ElementResolver_SyntheticIdentifier("${node.name}="), _definingLibrary);
+    } else if (element == null
+        && (node.inSetterContext() || node.parent is CommentReference)) {
+      element = _resolver.nameScope.lookup(
+          new SyntheticIdentifier("${node.name}=", node),
+          _definingLibrary);
     }
     ClassElement enclosingClass = _resolver.enclosingClass;
     if (element == null && enclosingClass != null) {
       InterfaceType enclosingType = enclosingClass.type;
       if (element == null && (node.inSetterContext() || node.parent is CommentReference)) {
         element = _lookUpSetter(null, enclosingType, node.name);
       }
       if (element == null && node.inGetterContext()) {
         element = _lookUpGetter(null, enclosingType, node.name);
       }
@@ skipping 82 matching lines @@
    */
   bool _shouldReportMissingMember(DartType type, Element member) {
     if (member != null || type == null || type.isDynamic || type.isBottom) {
       return false;
     }
     return true;
   }
 }
 
 /**
- * Instances of the class `SyntheticIdentifier` implement an identifier that can be used to
- * look up names in the lexical scope when there is no identifier in the AST structure. There is
- * 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.
+ * A `SyntheticIdentifier` is an identifier that can be used to look up names in
+ * the lexical scope when there is no identifier in the AST structure. There is
+ * 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.
  */
-class ElementResolver_SyntheticIdentifier extends Identifier {
+class SyntheticIdentifier extends Identifier {
   /**
    * The name of the synthetic identifier.
    */
   final String name;
 
   /**
-   * Initialize a newly created synthetic identifier to have the given name.
-   *
-   * @param name the name of the synthetic identifier
+   * The identifier to be highlighted in case of an error
    */
-  ElementResolver_SyntheticIdentifier(this.name);
+  final Identifier identifier;
+
+  /**
+   * Initialize a newly created synthetic identifier to have the given [name]
+   * and [identifier].
+   */
+  SyntheticIdentifier(this.name, this.identifier);
 
   @override
   accept(AstVisitor visitor) => null;
 
   @override
   sc.Token get beginToken => null;
 
   @override
   Element get bestElement => null;
 
   @override
   sc.Token get endToken => null;
 
   @override
+  int get length => identifier.length;
+
+  @override
+  int get offset => identifier.offset;
+
+  @override
   int get precedence => 16;
 
   @override
   Element get propagatedElement => null;
 
   @override
   Element get staticElement => null;
 
   @override
   void visitChildren(AstVisitor visitor) {
   }
 }
-