Change spanFromNode to spanFromSpannable.

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 operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(Node node);
@@ skipping 373 matching lines @@
    * Load and resolve the supertypes of [cls].
    *
    * Warning: do not call this method directly. It should only be
    * called by [resolveClass] and [ClassSupertypeResolver].
    */
   void loadSupertypes(ClassElement cls, Node from) {
     compiler.withCurrentElement(cls, () => measure(() {
       if (cls.supertypeLoadState == STATE_DONE) return;
       if (cls.supertypeLoadState == STATE_STARTED) {
         compiler.reportMessage(
-          compiler.spanFromNode(from),
+          compiler.spanFromSpannable(from),
           MessageKind.CYCLIC_CLASS_HIERARCHY.error([cls.name]),
           Diagnostic.ERROR);
         cls.supertypeLoadState = STATE_DONE;
         cls.allSupertypes = const Link<DartType>().prepend(
             compiler.objectClass.computeType(compiler));
         // TODO(ahe): We should also set cls.supertype here to avoid
         // creating a malformed class hierarchy.
         return;
       }
       cls.supertypeLoadState = STATE_STARTED;
@@ skipping 227 matching lines @@
     if (signature.requiredParameterCount != requiredParameterCount) {
       Node errorNode = node;
       if (node.parameters != null) {
         if (signature.requiredParameterCount < requiredParameterCount) {
           errorNode = node.parameters;
         } else {
           errorNode = node.parameters.nodes.skip(requiredParameterCount).head;
         }
       }
       compiler.reportMessage(
-          compiler.spanFromNode(errorNode),
+          compiler.spanFromSpannable(errorNode),
           messageKind.error([function.name]),
           Diagnostic.ERROR);
     }
     if (signature.optionalParameterCount != 0) {
       Node errorNode =
           node.parameters.nodes.skip(signature.requiredParameterCount).head;
       if (signature.optionalParametersAreNamed) {
         compiler.reportMessage(
-            compiler.spanFromNode(errorNode),
+            compiler.spanFromSpannable(errorNode),
             MessageKind.OPERATOR_NAMED_PARAMETERS.error([function.name]),
             Diagnostic.ERROR);
       } else {
         compiler.reportMessage(
-            compiler.spanFromNode(errorNode),
+            compiler.spanFromSpannable(errorNode),
             MessageKind.OPERATOR_OPTIONAL_PARAMETERS.error([function.name]),
             Diagnostic.ERROR);
       }
     }
   }
 
   reportErrorWithContext(Element errorneousElement,
                          MessageKind errorMessage,
                          Element contextElement,
                          MessageKind contextMessage) {
@@ skipping 751 matching lines @@
       inCheckContext = compiler.enableTypeAssertions,
       inCatchBlock = false,
       super(compiler);
 
   ResolutionEnqueuer get world => compiler.enqueuer.resolution;
 
   Element lookup(Node node, SourceString name) {
     Element result = scope.lookup(name);
     if (!Elements.isUnresolved(result)) {
       if (!inInstanceContext && result.isInstanceMember()) {
-        compiler.reportMessage(compiler.spanFromNode(node),
+        compiler.reportMessage(compiler.spanFromSpannable(node),
             MessageKind.NO_INSTANCE_AVAILABLE.error([name]),
             Diagnostic.ERROR);
         return new ErroneousElementX(MessageKind.NO_INSTANCE_AVAILABLE,
                                     [name],
                                     name, enclosingElement);
       } else if (result.isAmbiguous()) {
         AmbiguousElement ambiguous = result;
-        compiler.reportMessage(compiler.spanFromNode(node),
+        compiler.reportMessage(compiler.spanFromSpannable(node),
             ambiguous.messageKind.error(ambiguous.messageArguments),
             Diagnostic.ERROR);
         return new ErroneousElementX(ambiguous.messageKind,
                                     ambiguous.messageArguments,
                                     name, enclosingElement);
       }
     }
     return result;
   }
 
@@ skipping 693 matching lines @@
     if (node.isRedirectingFactoryBody) {
       handleRedirectingFactoryBody(node);
     } else {
       visit(node.expression);
     }
   }
 
   void handleRedirectingFactoryBody(Return node) {
     if (!enclosingElement.isFactoryConstructor()) {
       compiler.reportMessage(
-          compiler.spanFromNode(node),
+          compiler.spanFromSpannable(node),
           MessageKind.FACTORY_REDIRECTION_IN_NON_FACTORY.error([]),
           Diagnostic.ERROR);
       compiler.reportMessage(
-          compiler.spanFromElement(enclosingElement),
+          compiler.spanFromSpannable(enclosingElement),
           MessageKind.MISSING_FACTORY_KEYWORD.error([]),
           Diagnostic.INFO);
     }
     Element redirectionTarget = resolveRedirectingFactory(node);
     var type = mapping.getType(node.expression);
     if (type is InterfaceType && !type.isRaw) {
       unimplemented(node.expression, 'type arguments on redirecting factory');
     }
     useElement(node.expression, redirectionTarget);
     FunctionElement constructor = enclosingElement;
@@ skipping 610 matching lines @@
       if (interfaceType != null) {
         if (identical(interfaceType.kind, TypeKind.MALFORMED_TYPE)) {
           // Error has already been reported.
         } else if (!identical(interfaceType.kind, TypeKind.INTERFACE)) {
           // TODO(johnniwinther): Handle dynamic.
           TypeAnnotation typeAnnotation = link.head;
           error(typeAnnotation.typeName, MessageKind.CLASS_NAME_EXPECTED, []);
         } else {
           if (interfaceType == element.supertype) {
             compiler.reportMessage(
-                compiler.spanFromNode(node.superclass),
+                compiler.spanFromSpannable(node.superclass),
                 MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS.error([interfaceType]),
                 Diagnostic.ERROR);
             compiler.reportMessage(
-                compiler.spanFromNode(link.head),
+                compiler.spanFromSpannable(link.head),
                 MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS.error([interfaceType]),
                 Diagnostic.ERROR);
           }
           if (interfaces.contains(interfaceType)) {
             compiler.reportMessage(
-                compiler.spanFromNode(link.head),
+                compiler.spanFromSpannable(link.head),
                 MessageKind.DUPLICATE_IMPLEMENTS.error([interfaceType]),
                 Diagnostic.ERROR);
           }
           interfaces = interfaces.prepend(interfaceType);
           if (isBlackListed(interfaceType)) {
             error(link.head, MessageKind.CANNOT_IMPLEMENT, [interfaceType]);
           }
         }
       }
     }
@@ skipping 162 matching lines @@
     Element element = context.lookup(node.source);
     if (element == null) {
       error(node, MessageKind.CANNOT_RESOLVE_TYPE, [node]);
     } else if (!element.impliesType()) {
       error(node, MessageKind.NOT_A_TYPE, [node]);
     } else {
       if (element.isClass()) {
         loadSupertype(element, node);
       } else {
         compiler.reportMessage(
-          compiler.spanFromNode(node),
+          compiler.spanFromSpannable(node),
           MessageKind.CLASS_NAME_EXPECTED.error([]),
           Diagnostic.ERROR);
       }
     }
   }
 
   void visitSend(Send node) {
     Identifier prefix = node.receiver.asIdentifier();
     if (prefix == null) {
       error(node.receiver, MessageKind.NOT_A_PREFIX, [node.receiver]);
@@ skipping 206 matching lines @@
                                Diagnostic.ERROR);
       }
     } else {
       if (element.isGetter()) {
         if (!identical(formalParameters.getEndToken().next.stringValue,
                        // TODO(ahe): Remove the check for native keyword.
                        'native')) {
           if (compiler.rejectDeprecatedFeatures &&
               // TODO(ahe): Remove isPlatformLibrary check.
               !element.getLibrary().isPlatformLibrary) {
-            compiler.reportMessage(compiler.spanFromNode(formalParameters),
+            compiler.reportMessage(compiler.spanFromSpannable(formalParameters),
                                    MessageKind.EXTRA_FORMALS.error([]),
                                    Diagnostic.ERROR);
           } else {
             compiler.onDeprecatedFeature(formalParameters, 'getter parameters');
           }
         }
       }
       LinkBuilder<Element> parametersBuilder =
         visitor.analyzeNodes(formalParameters.nodes);
       requiredParameterCount  = parametersBuilder.length;
       parameters = parametersBuilder.toLink();
     }
     DartType returnType = compiler.resolveReturnType(element, returnNode);
     if (element.isSetter() && (requiredParameterCount != 1 ||
                                visitor.optionalParameterCount != 0)) {
       // If there are no formal parameters, we already reported an error above.
       if (formalParameters != null) {
-        compiler.reportMessage(compiler.spanFromNode(formalParameters),
+        compiler.reportMessage(compiler.spanFromSpannable(formalParameters),
                                MessageKind.ILLEGAL_SETTER_FORMALS.error([]),
                                Diagnostic.ERROR);
       }
     }
     return new FunctionSignatureX(parameters,
                                   visitor.optionalParameters,
                                   requiredParameterCount,
                                   visitor.optionalParameterCount,
                                   visitor.optionalParametersAreNamed,
                                   returnType);
@@ skipping 163 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }