Use serialized scope info to test incremental compiler.

dart/site/try/poi/scope_information_visitor.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 trydart.poi;
+library trydart.poi.scope_information_visitor;
 
-import 'dart:async' show
-    Completer,
-    Future;
+import 'package:compiler/src/elements/modelx.dart' as modelx;
 
-import 'dart:io' as io;
-
-import 'dart:convert' show
-    UTF8;
-
-import 'package:dart2js_incremental/dart2js_incremental.dart' show
-    reuseCompiler;
-
-import 'package:dart2js_incremental/library_updater.dart' show
-    LibraryUpdater;
-
-import 'package:compiler/src/source_file_provider.dart' show
-    FormattingDiagnosticHandler;
-
-import 'package:compiler/compiler.dart' as api;
-
-import 'package:compiler/src/dart2jslib.dart' show
-    Compiler,
-    CompilerTask,
-    Enqueuer,
-    QueueFilter,
-    WorkItem;
+import 'package:compiler/src/elements/modelx.dart' show
+    CompilationUnitElementX,
+    FieldElementX;
 
 import 'package:compiler/src/elements/visitor.dart' show
     ElementVisitor;
 
+import 'package:compiler/src/dart2jslib.dart' show
+    Compiler;
+
 import 'package:compiler/src/elements/elements.dart' show
     AbstractFieldElement,
     ClassElement,
     CompilationUnitElement,
     Element,
     ElementCategory,
     FunctionElement,
     LibraryElement,
     ScopeContainerElement;
 
-import 'package:compiler/src/elements/modelx.dart' as modelx;
-
-import 'package:compiler/src/elements/modelx.dart' show
-    DeclarationSite;
-
 import 'package:compiler/src/dart_types.dart' show
     DartType;
 
-import 'package:compiler/src/scanner/scannerlib.dart' show
-    EOF_TOKEN,
-    IDENTIFIER_TOKEN,
-    KEYWORD_TOKEN,
-    PartialClassElement,
-    PartialElement,
-    Token;
-
-import 'package:compiler/src/js/js.dart' show
-    js;
+/****************** IGNORE THIS ONLY FOR SMALL DIFF ****************************
 
 /// Enabled by the option --enable-dart-mind.  Controls if this program should
 /// be querying Dart Mind.
 bool isDartMindEnabled = false;
 
 /// Iterator over lines from standard input (or the argument array).
 Iterator<String> stdin;
 
 /// Enabled by the option --simulate-mutation. When true, this program will
 /// only prompt for one file name, and subsequent runs will read
@@ skipping 463 matching lines @@
   void processWorkItem(void f(WorkItem work), WorkItem work) {
     if (work.element.library.canonicalUri == script) {
       f(work);
       printWallClock('Processed ${work.element}.');
     } else {
       printWallClock('Skipped ${work.element}.');
     }
   }
 }
 
+*******************************************************************************/
+
 /**
  * Serializes scope information about an element. This is accomplished by
  * calling the [serialize] method on each element. Some elements need special
  * treatment, as their enclosing scope must also be serialized.
  */
 class ScopeInformationVisitor extends ElementVisitor/* <void> */ {
   // TODO(ahe): Include function parameters and local variables.
 
+  final Compiler compiler;
   final Element currentElement;
   final int position;
   final StringBuffer buffer = new StringBuffer();
   int indentationLevel = 0;
   ClassElement currentClass;
 
-  ScopeInformationVisitor(this.currentElement, this.position);
+  bool sortMembers = false;
+
+  bool ignoreImports = false;
+
+  ScopeInformationVisitor(this.compiler, this.currentElement, this.position);
 
   String get indentation => '  ' * indentationLevel;
 
   StringBuffer get indented => buffer..write(indentation);
 
   void visitElement(Element e) {
     serialize(e, omitEnclosing: false);
   }
 
   void visitLibraryElement(LibraryElement e) {
     bool isFirst = true;
     forEach(Element member) {
       if (!isFirst) {
         buffer.write(',');
       }
       buffer.write('\n');
       indented;
       serialize(member);
       isFirst = false;
     }
     serialize(
         e,
         // TODO(ahe): We omit the import scope if there is no current
         // class. That's wrong.
-        omitEnclosing: currentClass == null,
+        omitEnclosing: ignoreImports || currentClass == null,
         name: e.getLibraryName(),
         serializeEnclosing: () {
           // The enclosing scope of a library is a scope which contains all the
           // imported names.
           isFirst = true;
           buffer.write('{\n');
           indentationLevel++;
           indented.write('"kind": "imports",\n');
           indented.write('"members": [');
           indentationLevel++;
-          importScope(e).importScope.values.forEach(forEach);
+          sortElements(importScope(e).importScope.values).forEach(forEach);
           indentationLevel--;
           buffer.write('\n');
           indented.write('],\n');
           // The enclosing scope of the imported names scope is the superclass
           // scope of the current class.
           indented.write('"enclosing": ');
           serializeClassSide(
               currentClass.superclass, isStatic: false, includeSuper: true);
           buffer.write('\n');
           indentationLevel--;
           indented.write('}');
         },
         serializeMembers: () {
           isFirst = true;
-          localScope(e).values.forEach(forEach);
+          sortElements(localScope(e).values).forEach(forEach);
         });
   }
 
   void visitClassElement(ClassElement e) {
     currentClass = e;
     serializeClassSide(e, isStatic: true);
   }
 
   /// Serializes one of the "sides" a class. The sides of a class are "instance
   /// side" and "class side". These terms are from Smalltalk. The instance side
   /// is all the local instance members of the class (the members of the
   /// mixin), and the class side is the equivalent for static members and
   /// constructors.
   /// The scope chain is ordered so that the "class side" is searched before
   /// the "instance side".
   void serializeClassSide(
       ClassElement e,
       {bool isStatic: false,
        bool omitEnclosing: false,
        bool includeSuper: false}) {
+    e.ensureResolved(compiler);
     bool isFirst = true;
     var serializeEnclosing;
     String kind;
     if (isStatic) {
       kind = 'class side';
       serializeEnclosing = () {
         serializeClassSide(e, isStatic: false, omitEnclosing: omitEnclosing);
       };
     } else {
       kind = 'instance side';
     }
     if (includeSuper) {
       assert(!omitEnclosing && !isStatic);
       if (e.superclass == null) {
         omitEnclosing = true;
       } else {
         // Members of the superclass are represented as a separate scope.
         serializeEnclosing = () {
           serializeClassSide(
               e.superclass, isStatic: false, omitEnclosing: false,
               includeSuper: true);
         };
       }
     }
     serialize(
         e, omitEnclosing: omitEnclosing, serializeEnclosing: serializeEnclosing,
         kind: kind, serializeMembers: () {
-      e.forEachLocalMember((Element member) {
+      localMembersSorted(e).forEach((Element member) {
         // Filter out members that don't belong to this "side".
         if (member.isConstructor) {
           // In dart2js, some constructors aren't static, but that isn't
           // convenient here.
           if (!isStatic) return;
         } else if (member.isStatic != isStatic) {
           return;
         }
         if (!isFirst) {
           buffer.write(',');
         }
         buffer.write('\n');
         indented;
         serialize(member);
         isFirst = false;
       });
     });
   }
 
   void visitScopeContainerElement(ScopeContainerElement e) {
     bool isFirst = true;
     serialize(e, omitEnclosing: false, serializeMembers: () {
-      e.forEachLocalMember((Element member) {
+      localMembersSorted(e).forEach((Element member) {
         if (!isFirst) {
           buffer.write(',');
         }
         buffer.write('\n');
         indented;
         serialize(member);
         isFirst = false;
       });
     });
   }
@@ skipping 39 matching lines @@
             kind: kind,
             name: name);
       }
       return;
     }
     DartType type;
     int category = element.kind.category;
     if (category == ElementCategory.FUNCTION ||
         category == ElementCategory.VARIABLE ||
         element.isConstructor) {
-      type = element.computeType(cachedCompiler);
+      type = element.computeType(compiler);
     }
     if (name == null) {
       name = element.name;
     }
     if (kind == null) {
       kind = '${element.kind}';
     }
     buffer.write('{\n');
     indentationLevel++;
     if (name != '') {
@@ skipping 28 matching lines @@
       if (serializeEnclosing != null) {
         serializeEnclosing();
       } else {
         element.enclosingElement.accept(this);
       }
     }
     indentationLevel--;
     buffer.write('\n');
     indented.write('}');
   }
+
+  List<Element> localMembersSorted(ScopeContainerElement element) {
+    List<Element> result = <Element>[];
+    element.forEachLocalMember((Element member) {
+      result.add(member);
+    });
+    return sortElements(result);
+  }
+
+  List<Element> sortElements(Iterable<Element> elements) {
+    List<Element> result = new List<Element>.from(elements);
+    if (sortMembers) {
+      result.sort((Element a, Element b) => a.name.compareTo(b.name));
+    } else {
+      throw "Not sorting result";
+    }
+    return result;
+  }
 }
 
 modelx.ScopeX localScope(modelx.LibraryElementX element) => element.localScope;
 
 modelx.ImportScope importScope(modelx.LibraryElementX element) {
   return element.importScope;
 }
-
-class PoiTask extends CompilerTask {
-  PoiTask(Compiler compiler) : super(compiler);
-
-  String get name => 'POI';
-}