anchor.diff:    /// Initialize a newly created parameter element to have the given [name] and
     /// [nameOffset].
     ParameterElementImpl(String? name, int nameOffset) : super(name, nameOffset);
  -
  -  ParameterElementImpl.forLinkedNode(ElementImpl enclosing,
  -      Reference? reference, FormalParameterImpl linkedNode)
  -      : super.forLinkedNode(enclosing, reference, linkedNode) {
  -    assert(linkedNode.isNamed || reference == null);
  -    FormalParameterImpl.setDeclaredElement(linkedNode, this);
  -  }
  -
  -  factory ParameterElementImpl.forLinkedNodeFactory(
  -      ElementImpl enclosing, Reference? reference, FormalParameterImpl node) {
  -    if (node is FieldFormalParameter) {
  -      return FieldFormalParameterElementImpl.forLinkedNode(
  -        enclosing,
  -        reference,
  -        node,
  -      );
  -    } else if (node is FunctionTypedFormalParameter ||
  -        node is SimpleFormalParameter) {
  -      return ParameterElementImpl.forLinkedNode(enclosing, reference, node);
  -    } else {
  -      throw UnimplementedError('${node.runtimeType}');
  -    }
  -  }
   
     /// Creates a synthetic parameter with [name], [type] and [kind].
     factory ParameterElementImpl.synthetic(
  
positive.code: 
    @override
    ElementKind get kind => ElementKind.PARAMETER;
  
    @override
    String get name {
      if (linkedNode != null) {
        return linkedContext!
            .getFormalParameterName(linkedNode as FormalParameter);
      }
      return super.name;
    }
  
    @override
    int get nameOffset {
      if (linkedNode != null) {
        return enclosingUnit.linkedContext!.getNameOffset(linkedNode!);
      }
  
      return super.nameOffset;
    }
  
    @override
    ParameterKind get parameterKind {
      if (_parameterKind != null) return _parameterKind!;
  
      if (linkedNode != null) {
        final linkedNode = this.linkedNode as FormalParameterImpl;
        return linkedNode.kind;
      }
  
      // TODO(migration): Make it impossible by construction.
      throw StateError('The kind must set.');
    }
  
negative.code: 
    /// Return true if this parameter is explicitly marked as being covariant.
    bool get isExplicitlyCovariant {
      return hasModifier(Modifier.COVARIANT);
    }
  
  