Splitting SVG types out of dart:html.

utils/apidoc/html_diff.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.
 
 /**
  * A script to assist in documenting the difference between the dart:html API
  * and the old DOM API.
  */
 library html_diff;
 
 import 'dart:coreimpl';
 import 'dart:io';
 
 // TODO(rnystrom): Use "package:" URL (#4968).
 import '../../sdk/lib/_internal/dartdoc/lib/dartdoc.dart';
 import '../../sdk/lib/_internal/compiler/implementation/mirrors/mirrors.dart';
 import '../../sdk/lib/_internal/compiler/implementation/mirrors/mirrors_util.dart';
 
 // TODO(amouravski): There is currently magic that looks at dart:* libraries
 // rather than the declared library names. This changed due to recent syntax
 // changes. We should only need to look at the library 'html'.
-const HTML_LIBRARY_NAME = 'dart:html';
-const HTML_DECLARED_NAME = 'html';
+const List<String> HTML_LIBRARY_NAMES = const ['dart:html', 'dart:svg'];
+const List<String> HTML_DECLARED_NAMES = const ['html', 'svg'];
 
 /**
  * A class for computing a many-to-many mapping between the types and
  * members in `dart:html` and the MDN DOM types. This mapping is
  * based on two indicators:
  *
  *   1. Auto-detected wrappers. Most `dart:html` types correspond
  *      straightforwardly to a single `@domName` type, and
  *      have the same name.  In addition, most `dart:html` methods
  *      just call a single `@domName` method. This class
@@ skipping 31 matching lines @@
 
   static Compilation _compilation;
   static MirrorSystem _mirrors;
   static LibraryMirror dom;
 
   /**
    * Perform static initialization of [world]. This should be run before
    * calling [HtmlDiff.run].
    */
   static void initialize(Path libDir) {
-    _compilation = new Compilation.library(<Path>[new Path(HTML_LIBRARY_NAME)],
-                                           libDir);
+    var paths = <Path>[];
+    for (var libraryName in HTML_LIBRARY_NAMES) {
+      paths.add(new Path(libraryName));
+    }
+    _compilation = new Compilation.library(paths, libDir);
     _mirrors = _compilation.mirrors;
   }
 
   HtmlDiff({bool printWarnings: false}) :
     _printWarnings = printWarnings,
     htmlToDom = new Map<String, Set<String>>(),
     htmlTypesToDom = new Map<String, Set<String>>(),
     comments = new CommentMap();
 
   void warn(String s) {
     if (_printWarnings) {
       print('Warning: $s');
     }
   }
 
   /**
    * Computes the `@domName` to `dart:html` mapping, and
    * places it in [htmlToDom] and [htmlTypesToDom]. Before this is run, dart2js
    * should be initialized (via [parseOptions] and [initializeWorld]) and
    * [HtmlDiff.initialize] should be called.
    */
   void run() {
-    LibraryMirror htmlLib = _mirrors.libraries[HTML_DECLARED_NAME];
-    if (htmlLib == null) {
-      warn('Could not find $HTML_LIBRARY_NAME');
-      return;
-    }
-    for (ClassMirror htmlType in htmlLib.classes.values) {
-      final domTypes = htmlToDomTypes(htmlType);
-      if (domTypes.isEmpty) continue;
+    for (var libraryName in HTML_DECLARED_NAMES) {
+      var library = _mirrors.libraries[libraryName];
+      if (library == null) {
+        warn('Could not find $libraryName');
+        return;
+      }
+      for (ClassMirror type in library.classes.values) {
+        final domTypes = htmlToDomTypes(type);
+        if (domTypes.isEmpty) continue;
 
-      htmlTypesToDom.putIfAbsent(htmlType.qualifiedName,
-          () => new Set()).addAll(domTypes);
+        htmlTypesToDom.putIfAbsent(type.qualifiedName,
+            () => new Set()).addAll(domTypes);
 
-      htmlType.members.forEach(
-          (_, m) => _addMemberDiff(m, domTypes));
+        type.members.forEach(
+            (_, m) => _addMemberDiff(m, domTypes, library.simpleName));
+      }
     }
   }
 
   /**
    * Records the `@domName` to `dart:html` mapping for
    * [htmlMember] (from `dart:html`). [domTypes] are the
    * `@domName` type values that correspond to [htmlMember]'s
    * defining type.
    */
-  void _addMemberDiff(MemberMirror htmlMember, List<String> domTypes) {
+  void _addMemberDiff(MemberMirror htmlMember, List<String> domTypes,
+      String libraryName) {
     var domMembers = htmlToDomMembers(htmlMember, domTypes);
     if (htmlMember == null && !domMembers.isEmpty) {
-      warn('$HTML_LIBRARY_NAME member '
+      warn('$libraryName member '
            '${htmlMember.owner.simpleName}.'
            '${htmlMember.simpleName} has no corresponding '
-           '$HTML_LIBRARY_NAME member.');
+           '$libraryName member.');
     }
 
     if (htmlMember == null) return;
     if (!domMembers.isEmpty) {
       htmlToDom[htmlMember.qualifiedName] = domMembers;
     }
   }
 
   /**
    * Returns the `@domName` type values that correspond to
@@ skipping 90 matching lines @@
   Map<String, String> _getTags(String comment) {
     if (comment == null) return const <String, String>{};
     final re = const RegExp("@([a-zA-Z]+) ([^;]+)(?:;|\$)");
     final tags = <String, String>{};
     for (var m in re.allMatches(comment.trim())) {
       tags[m[1]] = m[2];
     }
     return tags;
   }
 }