Handle static invocation

pkg/compiler/lib/src/elements/elements.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.
 
 library elements;
 
 import '../common.dart';
 import '../common/resolution.dart' show Resolution;
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
 import '../common_elements.dart' show CommonElements;
 import '../ordered_typeset.dart' show OrderedTypeSet;
 import '../resolution/scope.dart' show Scope;
 import '../resolution/tree_elements.dart' show TreeElements;
 import '../script.dart';
 import 'package:front_end/src/fasta/scanner.dart'
     show Token, isUserDefinableOperator, isMinusOperator;
 import '../tree/tree.dart' hide AsyncModifier;
 import '../universe/call_structure.dart';
 import '../util/util.dart';
 import '../world.dart' show ClosedWorld;
 import 'entities.dart';
+import 'entity_utils.dart' as utils;
 import 'names.dart';
 import 'resolution_types.dart';
 import 'types.dart';
 import 'visitor.dart' show ElementVisitor;
 
 const int STATE_NOT_STARTED = 0;
 const int STATE_STARTED = 1;
 const int STATE_DONE = 2;
 
 class ElementCategory {
@@ skipping 502 matching lines @@
     if (element == null && selector.asIdentifier() == null) return true;
     if (element == null) return false;
     // foo() with foo a local or a parameter.
     return isLocal(element);
   }
 
   static String reconstructConstructorNameSourceString(FunctionEntity element) {
     if (element.name == '') {
       return element.enclosingClass.name;
     } else {
-      return reconstructConstructorName(element);
+      return utils.reconstructConstructorName(element);
     }
   }
 
-  // TODO(johnniwinther): Move this (other similar) to an entity_utils library.
-  static String reconstructConstructorName(FunctionEntity element) {
-    String className = element.enclosingClass.name;
-    if (element.name == '') {
-      return className;
-    } else {
-      return '$className\$${element.name}';
-    }
-  }
-
   static String constructorNameForDiagnostics(
       String className, String constructorName) {
     String classNameString = className;
     String constructorNameString = constructorName;
     return (constructorName == '')
         ? classNameString
         : "$classNameString.$constructorNameString";
   }
 
   /// Returns `true` if [name] is the name of an operator method.
@@ skipping 91 matching lines @@
     if (identical(op, '|=')) return '|';
     if (identical(op, '??=')) return '??';
 
     return null;
   }
 
   /// A `compareTo` function that places [Element]s in a consistent order based
   /// on the source code order.
   static int compareByPosition(Element a, Element b) {
     if (identical(a, b)) return 0;
-    int r = _compareLibraries(a.library, b.library);
+    int r = utils.compareLibrariesUris(
+        a.library.canonicalUri, b.library.canonicalUri);
     if (r != 0) return r;
-    r = _compareCompilationUnits(a.compilationUnit, b.compilationUnit);
+    r = utils.compareSourceUris(a.compilationUnit.script.readableUri,
+        b.compilationUnit.script.readableUri);
     if (r != 0) return r;
-    int offsetA = a.sourceOffset ?? -1;
-    int offsetB = b.sourceOffset ?? -1;
-    r = offsetA.compareTo(offsetB);
-    if (r != 0) return r;
-    r = a.name.compareTo(b.name);
-    if (r != 0) return r;
-    // Same file, position and name.  If this happens, we should find out why
-    // and make the order total and independent of hashCode.
-    return a.hashCode.compareTo(b.hashCode);
-  }
-
-  // Somewhat stable ordering for [LibraryElement]s
-  static int _compareLibraries(LibraryElement a, LibraryElement b) {
-    if (a == b) return 0;
-
-    int byCanonicalUriPath() {
-      return a.canonicalUri.path.compareTo(b.canonicalUri.path);
-    }
-
-    // Order: platform < package < other.
-    if (a.isPlatformLibrary) {
-      if (b.isPlatformLibrary) return byCanonicalUriPath();
-      return -1;
-    }
-    if (b.isPlatformLibrary) return 1;
-
-    if (a.isPackageLibrary) {
-      if (b.isPackageLibrary) return byCanonicalUriPath();
-      return -1;
-    }
-    if (b.isPackageLibrary) return 1;
-
-    return _compareCanonicalUri(a.canonicalUri, b.canonicalUri);
-  }
-
-  static int _compareCanonicalUri(Uri a, Uri b) {
-    int r = a.scheme.compareTo(b.scheme);
-    if (r != 0) return r;
-
-    // We would like the order of 'file:' Uris to be stable across different
-    // users or different builds from temporary directories.  We sort by
-    // pathSegments elements from the last to the first since that tends to find
-    // a stable distinction regardless of directory root.
-    List<String> aSegments = a.pathSegments;
-    List<String> bSegments = b.pathSegments;
-    int aI = aSegments.length;
-    int bI = bSegments.length;
-    while (aI > 0 && bI > 0) {
-      String aSegment = aSegments[--aI];
-      String bSegment = bSegments[--bI];
-      r = aSegment.compareTo(bSegment);
-      if (r != 0) return r;
-    }
-    return aI.compareTo(bI); // Shortest first.
-  }
-
-  static int _compareCompilationUnits(
-      CompilationUnitElement a, CompilationUnitElement b) {
-    if (a == b) return 0;
-    // Compilation units are compared only within the same library so we expect
-    // the Uris to usually be clustered together with a common scheme and path
-    // prefix.
-    Uri aUri = a.script.readableUri;
-    Uri bUri = b.script.readableUri;
-    return '${aUri}'.compareTo('${bUri}');
+    return utils.compareEntities(a, a.sourceOffset, -1, b, b.sourceOffset, -1);
   }
 
   static List<E> sortedByPosition<E extends Element>(Iterable<E> elements) {
     return elements.toList()..sort(compareByPosition);
   }
 
   static bool isFixedListConstructorCall(
       ConstructorEntity element, Send node, CommonElements commonElements) {
     return commonElements.isUnnamedListConstructor(element) &&
         node.isCall &&
@@ skipping 1228 matching lines @@
   /// by a field.
   bool get isDeclaredByField;
 
   /// Returns `true` if this member is abstract.
   bool get isAbstract;
 
   /// If abstract, [implementation] points to the overridden concrete member,
   /// if any. Otherwise [implementation] points to the member itself.
   Member get implementation;
 }