anchor.diff:      }
     }
   
  -  visitCovariant(DartType type) => type?.accept(this);
  -
  -  visitInvariant(DartType type) => shaker._invariantVisitor.visit(type);
  -
  -  visitInvalidType(InvalidType node) {}
  -
  -  visitDynamicType(DynamicType node) {
  +  void visitCovariant(DartType type) => type?.accept(this);
  +
  +  void visitInvariant(DartType type) => shaker._invariantVisitor.visit(type);
  +
  +  void visitInvalidType(InvalidType node) {}
  +
  +  void visitDynamicType(DynamicType node) {
       // TODO(asgerf): Find a suitable model for untyped externals, e.g. track
       // them to the first type boundary.
     }
   
  -  visitVoidType(VoidType node) {}
  -
  -  visitVectorType(VectorType node) {}
  -
  -  visitInterfaceType(InterfaceType node) {
  +  void visitVoidType(VoidType node) {}
  +
  +  void visitVectorType(VectorType node) {}
  +
  +  void visitInterfaceType(InterfaceType node) {
       if (isCovariant) {
         shaker._addInstantiatedExternalSubclass(node.classNode);
       }
  
positive.code:     }
    }
  
    visitTypedefType(TypedefType node) {
      shaker.addUsedTypedef(node.typedefNode);
    }
  
    visitFunctionType(FunctionType node) {
      visit(node.returnType);
      for (int i = 0; i < node.positionalParameters.length; ++i) {
        visitContravariant(node.positionalParameters[i]);
  
negative.code:     }
    }
  
    void visitTypeParameterType(TypeParameterType node) {}
  
    /// Just treat a couple of whitelisted classes as having covariant type
    /// parameters.
  