anchor.diff:  
     @override
     late final Map<String, ModelCommentReference> commentRefs = () {
  -    var _commentRefs = <String, ModelCommentReference>{};
  +    var commentRefsBuilder = <String, ModelCommentReference>{};
       for (var from in documentationFrom) {
         if (from is ModelElement) {
           var checkReferences = [from];
  
positive.code:     var library = modelBuilder.fromElement(element!.library!) as Library?;
      if (library == null) {
        warn(PackageWarning.noDefiningLibraryFound);
      }
      Library? fallback;
      if (enclosingElement is ModelElement) {
        fallback = (enclosingElement as ModelElement).definingLibrary;
      }
      return library ?? fallback ?? this.library!;
    }
  
    Library? _canonicalLibrary;
  
    // [_canonicalLibrary] can be null so we can't check against null to see
    // whether we tried to compute it before.
    bool _canonicalLibraryIsSet = false;
  
    @override
    Library? get canonicalLibrary {
      if (!_canonicalLibraryIsSet) {
        // This is not accurate if we are constructing the Package.
        assert(packageGraph.allLibrariesAdded);
  
        // Privately named elements can never have a canonical library, so
        // just shortcut them out.
        if (!utils.hasPublicName(element!)) {
          _canonicalLibrary = null;
        } else if (!packageGraph.localPublicLibraries.contains(definingLibrary)) {
          _canonicalLibrary = _searchForCanonicalLibrary();
        } else {
          _canonicalLibrary = definingLibrary;
        }
        // Only pretend when not linking to remote packages.
        if (this is Inheritable && !config.linkToRemote) {
          if ((this as Inheritable).isInherited &&
              _canonicalLibrary == null &&
              packageGraph.publicLibraries.contains(library)) {
            // In the event we've inherited a field from an object that isn't
            // directly reexported, we may need to pretend we are canonical for
            // this.
            _canonicalLibrary = library;
          }
        }
        _canonicalLibraryIsSet = true;
      }
      assert(_canonicalLibrary == null ||
          packageGraph.publicLibraries.contains(_canonicalLibrary));
      return _canonicalLibrary;
    }
  
    Library? _searchForCanonicalLibrary() {
      var thisAndExported = definingLibrary.exportedInLibraries;
  
negative.code:   bool get hasCategoryNames => false;
  
    // Stub for mustache.
    Iterable<Category?> get displayedCategories => const [];
  
    Set<Library>? get exportedInLibraries {
      return library!.packageGraph.libraryElementReexportedBy[element!.library!];
    }
  
    @override
    late final ModelNode? modelNode = packageGraph.getModelNodeFor(element);
  
    // Skips over annotations with null elements or that are otherwise
    // supposed to be invisible (@pragma).  While technically, null elements
    // indicate invalid code from analyzer's perspective they are present in
    // sky_engine (@Native) so we don't want to crash here.
    late final Iterable<Annotation> annotations = element!.metadata
        .whereNot((m) =>
            m.element == null ||
            packageGraph
                .specialClasses[SpecialClass.pragma]!.element!.constructors
                .contains(m.element))
        .map((m) => Annotation(m, library, packageGraph))
        .toList(growable: false);
  
    @override
    late final bool isPublic = () {
  