Update references for exported variables and methods.

pkg/docgen/lib/docgen.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.
 
 /// **docgen** is a tool for creating machine readable representations of Dart
 /// code metadata, including: classes, members, comments and annotations.
 ///
 /// docgen is run on a `.dart` file or a directory containing `.dart` files.
 ///
 ///      $ dart docgen.dart [OPTIONS] [FILE/DIR]
@@ skipping 745 matching lines @@
     });
 
     var linkResolver = (name) => fixReferenceWithScope(name, itemToDocument);
     commentText = commentText == null ? '' :
         markdown.markdownToHtml(commentText.trim(), linkResolver: linkResolver,
             inlineSyntaxes: markdownSyntaxes);
     return commentText;
   }
 
   /// Returns a map of [Variable] objects constructed from [mirrorMap].
+  /// The optional parameter [containingLibrary] is contains data for variables
+  /// defined at the top level of a library (potentially for exporting
+  /// purposes).
   Map<String, Variable> _createVariables(Map<String,
-      VariableMirror> mirrorMap) {
+      VariableMirror> mirrorMap, [Library containingLibrary]) {
     var data = {};
     // TODO(janicejl): When map to map feature is created, replace the below
     // with a filter. Issue(#9590).
     mirrorMap.forEach((String mirrorName, VariableMirror mirror) {
       if (_includePrivate || !_isHidden(mirror)) {
-        entityMap[docName(mirror)] = new Variable(mirrorName, mirror);
+        if (containingLibrary != null && mirror.owner.qualifiedName !=
+            containingLibrary.mirror.qualifiedName) {
+          entityMap[docName(mirror)] = new ExportedVariable(mirrorName, mirror,
+              containingLibrary);
+        } else {
+          entityMap[docName(mirror)] = new Variable(mirrorName, mirror);
+        }
         data[mirrorName] = entityMap[docName(mirror)];
       }
     });
     return data;
   }
 
   /// Returns a map of [Method] objects constructed from [mirrorMap].
-  MethodGroup _createMethods(Map<String, MethodMirror> mirrorMap) {
+  /// The optional parameter [containingLibrary] is contains data for variables
+  /// defined at the top level of a library (potentially for exporting
+  /// purposes).
+  MethodGroup _createMethods(Map<String, MethodMirror> mirrorMap,
+      [Library containingLibrary]) {
     var group = new MethodGroup();
     mirrorMap.forEach((String mirrorName, MethodMirror mirror) {
       if (_includePrivate || !mirror.isPrivate) {
-        group.addMethod(mirror);
+        group.addMethod(mirror, containingLibrary);
       }
     });
     return group;
   }
 
   /// Returns a map of [Parameter] objects constructed from [mirrorList].
   Map<String, Parameter> _createParameters(List<ParameterMirror> mirrorList) {
     var data = {};
     mirrorList.forEach((ParameterMirror mirror) {
       data[mirror.simpleName] = new Parameter(mirror.simpleName,
@@ skipping 70 matching lines @@
   String packageName = '';
   bool hasBeenCheckedForPackage = false;
   String packageIntro;
 
   Map<String, Exported> _exportedMembers;
 
   Library(LibraryMirror libraryMirror) : super(libraryMirror) {
     var exported = _calcExportedItems(libraryMirror);
     _createClasses(exported['classes']..addAll(libraryMirror.classes));
     this.functions = _createMethods(
-        exported['methods']..addAll(libraryMirror.functions));
+        exported['methods']..addAll(libraryMirror.functions), this);
     this.variables = _createVariables(
-        exported['variables']..addAll(libraryMirror.variables));
+        exported['variables']..addAll(libraryMirror.variables), this);
 
     var exportedVariables = {};
     variables.forEach((key, value) {
       if (value is ExportedVariable) {
         exportedVariables[key] = value;
       }
     });
     _exportedMembers = new Map.from(this.classes.exported)
         ..addAll(this.functions.exported)
         ..addAll(exportedVariables);
@@ skipping 464 matching lines @@
     return super.comment;
   }
 }
 
 class ExportedVariable extends Variable implements Exported {
   Library _exportingLibrary;
 
   ExportedVariable(String variableName, VariableMirror originalVariable,
       Library this._exportingLibrary) : super(variableName, originalVariable);
 
-  String get fileName => '${_exportingLibrary.packageName}/' +
-      super.fileName.substring(packagePrefix.length);
+  String get fileName => path.join(_exportingLibrary.packageName,
+          _exportingLibrary.mirror.qualifiedName + '.' + super.name);
 
   void updateExports(Map<String, Indexable> libraryExports) {
     // TODO(efortuna): if this class points to another exported class or type
     // of some sort, then that reference needs to be updated here.
     /* these need to be updated:
     'comment': comment,
     'type': new List.filled(1, type.toMap()),
     'annotations': annotations.map((a) => a.toMap()).toList()
     */
   }
@@ skipping 68 matching lines @@
     return super.comment;
   }
 }
 
 class ExportedMethod extends Method implements Exported {
   Library _exportingLibrary;
 
   ExportedMethod(MethodMirror originalMethod, Library this._exportingLibrary) :
       super(originalMethod);
 
-  String get fileName => '${_exportingLibrary.packageName}/' +
-      super.fileName.substring(packagePrefix.length);
+  // TODO(efortuna): Refactor this code so the exported items can share this
+  // behavior.
+  String get fileName => path.join(_exportingLibrary.packageName,
+      _exportingLibrary.mirror.qualifiedName + '.' + super.name);
 
   void updateExports(Map<String, Indexable> libraryExports) {
     // TODO(efortuna): if this class points to another exported class or type
     // of some sort, then that reference needs to be updated here.
     /* these need to be updated:
     'qualifiedName': qualifiedName,
     'comment': comment,
     'commentFrom': commentInheritedFrom,
     'return': new List.filled(1, returnType.toMap()),
     'parameters': recurseMap(parameters),
@@ skipping 16 matching lines @@
   Map<String, Exported> get exported {
     var exported = {};
     for (Map<String, Method> group in [setters, getters, constructors,
       operators, regularMethods]) {
       exported = _filterMap(exported, group,
           (value) => value is ExportedMethod);
     }
     return exported;
   }
 
-  void addMethod(MethodMirror mirror) {
-    var method = new Method(mirror);
+  /// The optional parameter [containingLibrary] is contains data for variables
+  /// defined at the top level of a library (potentially for exporting
+  /// purposes).
+  void addMethod(MethodMirror mirror, [Library containingLibrary]) {
+    var method;
+    if (containingLibrary != null && mirror.owner.qualifiedName !=
+        containingLibrary.mirror.qualifiedName) {
+      method = new ExportedMethod(mirror, containingLibrary);
+    } else {
+      method = new Method(mirror);
+    }
     entityMap[docName(mirror)] = method;
     if (mirror.isSetter) {
       setters[mirror.simpleName] = method;
     } else if (mirror.isGetter) {
       getters[mirror.simpleName] = method;
     } else if (mirror.isConstructor) {
       constructors[mirror.simpleName] = method;
     } else if (mirror.isOperator) {
       operators[mirror.simpleName] = method;
     } else if (mirror.isRegularMethod) {
@@ skipping 155 matching lines @@
 /// Remove statics from the map of inherited items before adding them.
 Map _filterStatics(Map items) {
   var result = {};
   items.forEach((name, item) {
     if (!item.isStatic) {
       result[name] = item;
     }
   });
   return result;
 }