anchor.diff:  import 'package:path/path.dart' as pathos;
   
   /**
  - * Return the raw string value of the variable with the given [name],
  - * or `null` of the variable is not defined.
  - */
  -typedef String _GetDeclaredVariable(String name);
  -
  -/**
    * Unlinked and linked information about a [PubPackage].
    */
   class LinkedPubPackage {
  
positive.code:   }
  
    /**
     * Attempt to find the linked bundle that corresponds to the given [node]
     * with all its transitive dependencies and put it into [_LinkNode.linked].
     */
    void _readLinked(_LinkNode node, bool strong) {
      String hash = node.linkedHash;
      if (hash != null) {
        String fileName = _getLinkedName(hash, strong);
        File file = node.package.folder.getChildAssumingFile(fileName);
        // Try to find in the cache.
        PackageBundle linked = linkedBundleMap[file.path];
        if (linked != null) {
          node.linked = linked;
          return;
        }
        // Try to read from the file system.
        if (file.exists) {
          try {
            List<int> bytes = file.readAsBytesSync();
            linked = new PackageBundle.fromBuffer(bytes);
            linkedBundleMap[file.path] = linked;
            node.linked = linked;
          } on FileSystemException {
            // Ignore file system exceptions.
          }
        }
      }
    }
  
    /**
     * Schedule delayed computation of the next package unlinked bundle from the
     * set of [packagesToComputeUnlinked].  We delay each computation because we
     * want operations in analysis server to proceed, and computing bundles of
  
negative.code:     signature.addInt(sortedNameList.length);
      for (String name in sortedNameList) {
        signature.addString(name);
        signature.addString(linker._getDeclaredVariable(name) ?? '');
      }
    }
  
    /**
     * Compute the set of existing transitive dependencies for this node.
     * If any `package` dependency cannot be resolved, but it is one of the
     * [listedPackages] then set [failed] to `true`.
     * Only [unlinked] is used, so this method can be called before linking.
     */
    void computeTransitiveDependencies() {
      if (transitiveDependencies == null) {
        transitiveDependencies = new Set<_LinkNode>();
  
        void appendDependencies(_LinkNode node) {
          if (transitiveDependencies.add(node)) {
            node.dependencies.forEach(appendDependencies);
          }
        }
  
        appendDependencies(this);
        if (transitiveDependencies.any((node) => node.failed)) {
          failed = true;
        }
      }
    }
  
    @override
    String toString() => package.toString();
  }
  
  /**
  