Fix leftover checks for dart- names in docgen

pkg/docgen/lib/src/models/class.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 docgen.models.clazz;
 
 import '../exports/dart2js_mirrors.dart' as dart2js_mirrors;
 import '../exports/mirrors_util.dart' as dart2js_util;
 import '../exports/source_mirrors.dart';
 
@@ skipping 150 matching lines @@
       }
     });
     return result;
   }
 
   /// Add the subclass to the class.
   ///
   /// If [this] is private (or an intermediary mixin class), it will add the
   /// subclass to the list of subclasses in the superclasses.
   void addSubclass(Class subclass) {
-    if (docName == 'dart-core.Object') return;
+    if (docName == 'dart:core.Object') return;
 
     if (!includePrivateMembers && isPrivate || mirror.isNameSynthetic) {
       if (_superclass != null) _superclass.addSubclass(subclass);
       interfaces.forEach((interface) {
         interface.addSubclass(subclass);
       });
     } else {
       subclasses.add(subclass);
     }
   }
 
   /// Check if this [Class] is an error or exception.
   bool isError() {
-    if (qualifiedName == 'dart-core.Error' ||
-        qualifiedName == 'dart-core.Exception')
+    if (qualifiedName == 'dart:core.Error' ||
+        qualifiedName == 'dart:core.Exception')
       return true;
     for (var interface in interfaces) {
       if (interface.isError()) return true;
     }
     if (_superclass == null) return false;
     return _superclass.isError();
   }
 
   /// Makes sure that all methods with inherited equivalents have comments.
   void ensureComments() {
@@ skipping 11 matching lines @@
     // we need to populate the comments for all methods. so that the subclasses
     // can get for their inherited versions the comments.
     methods.forEach((qualifiedName, method) {
       if (!method.mirror.isConstructor) method.ensureCommentFor(method);
     });
   }
 
   /// If a class extends a private superclass, find the closest public
   /// superclass of the private superclass.
   String validSuperclass() {
-    if (_superclass == null) return 'dart-core.Object';
+    if (_superclass == null) return 'dart:core.Object';
     if (_superclass.isVisible) return _superclass.qualifiedName;
     return _superclass.validSuperclass();
   }
 
   /// Generates a map describing the [Class] object.
   Map toMap() => {
     'name': name,
     'qualifiedName': qualifiedName,
     'comment': comment,
     'isAbstract' : isAbstract,
     'superclass': validSuperclass(),
     'implements': interfaces.where((i) => i.isVisible)
         .map((e) => e.qualifiedName).toList(),
     'subclass': (subclasses.toList()..sort())
         .map((x) => x.qualifiedName).toList(),
     'variables': recurseMap(variables),
     'inheritedVariables': recurseMap(inheritedVariables),
     'methods': expandMethodMap(methods),
     'inheritedMethods': expandMethodMap(inheritedMethods),
     'annotations': annotations.map((a) => a.toMap()).toList(),
     'generics': recurseMap(generics)
   };
 
   int compareTo(Class other) => name.compareTo(other.name);
 
   bool isValidMirror(DeclarationMirror mirror) => mirror is ClassMirror;
 }