anchor.diff:  
     @override
     LinkedNodeBuilder visitDefaultFormalParameter(DefaultFormalParameter node) {
  +    var defaultValue = node.defaultValue;
  +    if (!_isSerializableExpression(defaultValue)) {
  +      defaultValue = null;
  +    }
  +
       var builder = LinkedNodeBuilder.defaultFormalParameter(
  -      defaultFormalParameter_defaultValue: node.defaultValue?.accept(this),
  +      defaultFormalParameter_defaultValue: defaultValue?.accept(this),
         defaultFormalParameter_kind: _toParameterKind(node),
         defaultFormalParameter_parameter: node.parameter.accept(this),
         informativeId: getInformativeId(node),
  
positive.code: 
    _ElementComponents(this.rawElement, this.definingType);
  }
  
negative.code:     return _linkingContext.writeType(type);
    }
  
    /// Return `true` if the expression might be successfully serialized.
    ///
    /// This does not mean that the expression is constant, it just means that
    /// we know that it might be serialized and deserialized. For example
    /// function expressions are problematic, and are not necessary to
    /// deserialize, so we choose not to do this.
    static bool _isSerializableExpression(Expression node) {
      if (node == null) return false;
  
      var visitor = _IsSerializableExpressionVisitor();
      node.accept(visitor);
      return visitor.result;
    }
  
    static LinkedNodeFormalParameterKind _toParameterKind(FormalParameter node) {
      if (node.isRequiredPositional) {
        return LinkedNodeFormalParameterKind.requiredPositional;
  