Refactor DartTypeVisitor and ElementVisitor.

pkg/compiler/lib/src/dump_info.dart

 // Copyright (c) 2013, 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 dump_info;
 
 import 'dart:convert' show
     HtmlEscape,
     JsonEncoder,
     StringConversionSink,
@@ skipping 62 matching lines @@
         if (elementJson != null) {
           innerMapper["$k"] = elementJson;
         }
       });
       json[mapper.name] = innerMapper;
     }
     return json;
   }
 }
 
-class ElementToJsonVisitor extends ElementVisitor<Map<String, dynamic>> {
+class ElementToJsonVisitor
+    extends BaseElementVisitor<Map<String, dynamic>, dynamic> {
   final GroupedIdMapper mapper = new GroupedIdMapper();
   final Compiler compiler;
 
   final Map<Element, Map<String, dynamic>> jsonCache = {};
 
   String dart2jsVersion;
 
   ElementToJsonVisitor(this.compiler);
 
   void run() {
     Backend backend = compiler.backend;
 
     dart2jsVersion = compiler.hasBuildId ? compiler.buildId : null;
 
     for (var library in compiler.libraryLoader.libraries.toList()) {
-      library.accept(this);
+      apply(library);
     }
   }
 
+  Map<String, dynamic> apply(Element e, [_]) => e.accept(this, null);

[floitsch, 2015/04/21 13:10:31]

usually we call this "visit".

[Johnni Winther, 2015/04/21 13:37:05]

Done.

+
   // If keeping the element is in question (like if a function has a size
   // of zero), only keep it if it holds dependencies to elsewhere.
   bool shouldKeep(Element element) {
     return compiler.dumpInfoTask.selectorsFromElement.containsKey(element)
         || compiler.dumpInfoTask.inlineCount.containsKey(element);
   }
 
   Map<String, dynamic> toJson() {
     return mapper._toJson(this);
   }
 
   // Memoization of the JSON creating process.
   Map<String, dynamic> process(Element element) {
-    return jsonCache.putIfAbsent(element, () => element.accept(this));
+    return jsonCache.putIfAbsent(element, () => apply(element));
   }
 
   // Returns the id of an [element] if it has already been processed.
   // If the element has not been processed, this function does not
   // process it, and simply returns null instead.
   String idOf(Element element) {
     if (jsonCache.containsKey(element) && jsonCache[element] != null) {
       return jsonCache[element]['id'];
     } else {
       return null;
     }
   }
 
-  Map<String, dynamic> visitElement(Element element) {
+  Map<String, dynamic> visitElement(Element element, _) {
     return null;
   }
 
-  Map<String, dynamic> visitConstructorBodyElement(ConstructorBodyElement e) {
-    return visitFunctionElement(e.constructor);
+  Map<String, dynamic> visitConstructorBodyElement(
+      ConstructorBodyElement e, _) {
+    return visitFunctionElement(e.constructor, _);
   }
 
-  Map<String, dynamic> visitLibraryElement(LibraryElement element) {
+  Map<String, dynamic> visitLibraryElement(LibraryElement element, _) {
     var id = mapper._library.add(element);
     List<String> children = <String>[];
 
     String libname = element.getLibraryName();
     libname = libname == "" ? "<unnamed>" : libname;
 
     int size = compiler.dumpInfoTask.sizeOf(element);
 
     LibraryElement contentsOfLibrary = element.isPatched
       ? element.patch : element;
     contentsOfLibrary.forEachLocalMember((Element member) {
       Map<String, dynamic> childJson = this.process(member);
       if (childJson == null) return;
       children.add(childJson['id']);
     });
 
     if (children.length == 0 && !shouldKeep(element)) {
       return null;
     }
 
     return {
       'kind': 'library',
       'name': libname,
       'size': size,
       'id': id,
       'children': children
     };
   }
 
-  Map<String, dynamic> visitTypedefElement(TypedefElement element) {
+  Map<String, dynamic> visitTypedefElement(TypedefElement element, _) {
     String id = mapper._typedef.add(element);
     return element.alias == null
       ? null
       : {
         'id': id,
         'type': element.alias.toString(),
         'kind': 'typedef',
         'name': element.name
       };
   }
 
-  Map<String, dynamic> visitFieldElement(FieldElement element) {
+  Map<String, dynamic> visitFieldElement(FieldElement element, _) {
     String id = mapper._field.add(element);
     List<String> children = [];
     StringBuffer emittedCode = compiler.dumpInfoTask.codeOf(element);
 
     TypeMask inferredType =
         compiler.typesTask.getGuaranteedTypeOfElement(element);
     // If a field has an empty inferred type it is never used.
     if (inferredType == null || inferredType.isEmpty || element.isConst) {
       return null;
     }
@@ skipping 25 matching lines @@
       'type': element.type.toString(),
       'inferredType': inferredType.toString(),
       'name': element.name,
       'children': children,
       'size': size,
       'code': code,
       'outputUnit': mapper._outputUnit.add(outputUnit)
     };
   }
 
-  Map<String, dynamic> visitClassElement(ClassElement element) {
+  Map<String, dynamic> visitClassElement(ClassElement element, _) {
     String id = mapper._class.add(element);
     List<String> children = [];
 
     int size = compiler.dumpInfoTask.sizeOf(element);
     JavaScriptBackend backend = compiler.backend;
 
     Map<String, dynamic> modifiers = { 'abstract': element.isAbstract };
 
     element.forEachLocalMember((Element member) {
       Map<String, dynamic> childJson = this.process(member);
@@ skipping 38 matching lines @@
       'name': element.name,
       'size': size,
       'kind': 'class',
       'modifiers': modifiers,
       'children': children,
       'id': id,
       'outputUnit': mapper._outputUnit.add(outputUnit)
     };
   }
 
-  Map<String, dynamic> visitFunctionElement(FunctionElement element) {
+  Map<String, dynamic> visitFunctionElement(FunctionElement element, _) {
     String id = mapper._function.add(element);
     String name = element.name;
     String kind = "function";
     List<String> children = [];
     List<Map<String, dynamic>> parameters = [];
     String inferredReturnType = null;
     String returnType = null;
     String sideEffects = null;
     String code = "";
 
@@ skipping 366 matching lines @@
     ChunkedConversionSink<Object> sink =
       encoder.startChunkedConversion(
           new StringConversionSink.fromStringSink(buffer));
     sink.add(outJson);
     compiler.reportInfo(NO_LOCATION_SPANNABLE,
         const MessageKind(
             "View the dumped .info.json file at "
             "https://dart-lang.github.io/dump-info-visualizer"));
   }
 }