Elements. Remove ConstructorElementMixin.

Change-Id: I4a5391d4a886f6d69c7bec35c86bd6b4e82d9c03
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/437261
Reviewed-by: Paul Berry <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

pkg/analyzer/lib/src/dart/element/display_string_builder.dart

@@ -80,11 +80,20 @@ class ElementDisplayStringBuilder {
     _write(path);
   }
 
-  void writeConstructorElement(ConstructorElementMixin element) {
-    if (element.isAugmentation) {
-      _write('augment ');
-    }
+  void writeConstructorElement(ConstructorElementMixin2 element) {
+    _writeType(element.returnType);
+    _write(' ');
+
+    _write(element.displayName);
+
+    _writeFormalParameters2(
+      element.formalParameters,
+      forElement: true,
+      allowMultiline: true,
+    );
+  }
 
+  void writeConstructorFragment(ConstructorFragmentImpl element) {
     _writeType(element.returnType);
     _write(' ');
 
@@ -487,6 +496,65 @@ class ElementDisplayStringBuilder {
     _write(')');
   }
 
+  void _writeFormalParameters2(
+    List<FormalParameterElementMixin> parameters, {
+    required bool forElement,
+    bool allowMultiline = false,
+  }) {
+    // Assume the display string looks better wrapped when there are at least
+    // three parameters. This avoids having to pre-compute the single-line
+    // version and know the length of the function name/return type.
+    var multiline = allowMultiline && _multiline && parameters.length >= 3;
+
+    // The prefix for open groups is included in separator for single-line but
+    // not for multiline so must be added explicitly.
+    var openGroupPrefix = multiline ? ' ' : '';
+    var separator = multiline ? ',' : ', ';
+    var trailingComma = multiline ? ',\n' : '';
+    var parameterPrefix = multiline ? '\n  ' : '';
+
+    _write('(');
+
+    _WriteFormalParameterKind? lastKind;
+    var lastClose = '';
+
+    void openGroup(_WriteFormalParameterKind kind, String open, String close) {
+      if (lastKind != kind) {
+        _write(lastClose);
+        if (lastKind != null) {
+          // We only need to include the space before the open group if there
+          // was a previous parameter, otherwise it goes immediately after the
+          // open paren.
+          _write(openGroupPrefix);
+        }
+        _write(open);
+        lastKind = kind;
+        lastClose = close;
+      }
+    }
+
+    for (var i = 0; i < parameters.length; i++) {
+      if (i != 0) {
+        _write(separator);
+      }
+
+      var parameter = parameters[i];
+      if (parameter.isRequiredPositional) {
+        openGroup(_WriteFormalParameterKind.requiredPositional, '', '');
+      } else if (parameter.isOptionalPositional) {
+        openGroup(_WriteFormalParameterKind.optionalPositional, '[', ']');
+      } else if (parameter.isNamed) {
+        openGroup(_WriteFormalParameterKind.named, '{', '}');
+      }
+      _write(parameterPrefix);
+      _writeWithoutDelimiters2(parameter, forElement: forElement);
+    }
+
+    _write(trailingComma);
+    _write(lastClose);
+    _write(')');
+  }
+
   void _writeNullability(NullabilitySuffix nullabilitySuffix) {
     if (_withNullability) {
       switch (nullabilitySuffix) {
@@ -591,6 +659,30 @@ class ElementDisplayStringBuilder {
     }
   }
 
+  void _writeWithoutDelimiters2(
+    FormalParameterElementMixin element, {
+    required bool forElement,
+  }) {
+    if (element.isRequiredNamed) {
+      _write('required ');
+    }
+
+    _writeType(element.type);
+
+    if (forElement || element.isNamed) {
+      _write(' ');
+      _write(element.displayName);
+    }
+
+    if (forElement) {
+      var defaultValueCode = element.defaultValueCode;
+      if (defaultValueCode != null) {
+        _write(' = ');
+        _write(defaultValueCode);
+      }
+    }
+  }
+
   static FunctionTypeImpl _uniqueTypeParameters(FunctionTypeImpl type) {
     if (type.typeParameters.isEmpty) {
       return type;

pkg/analyzer/lib/src/dart/element/element.dart

@@ -901,6 +901,20 @@ class ConstructorElementImpl extends ExecutableElementImpl
     firstFragment.computeConstantDependencies();
   }
 
+  @override
+  String displayString2({
+    bool multiline = false,
+    bool preferTypeAlias = false,
+  }) {
+    // TODO(scheglov): de-duplicate
+    var builder = ElementDisplayStringBuilder(
+      multiline: multiline,
+      preferTypeAlias: preferTypeAlias,
+    );
+    builder.writeConstructorElement(this);
+    return builder.toString();
+  }
+
   @override
   void visitChildren2<T>(ElementVisitor2<T> visitor) {
     for (var child in children2) {
@@ -909,27 +923,6 @@ class ConstructorElementImpl extends ExecutableElementImpl
   }
 }
 
-mixin ConstructorElementMixin implements ExecutableElementOrMember {
-  @override
-  ConstructorFragmentImpl get declaration;
-
-  /// Whether the constructor is a const constructor.
-  bool get isConst;
-
-  /// Whether the constructor can be used as a default constructor - unnamed,
-  /// and has no required parameters.
-  bool get isDefaultConstructor;
-
-  /// Whether the constructor represents a factory constructor.
-  bool get isFactory;
-
-  /// Whether the constructor represents a generative constructor.
-  bool get isGenerative;
-
-  @override
-  InterfaceTypeImpl get returnType;
-}
-
 /// Common implementation for methods defined in [ConstructorElement].
 mixin ConstructorElementMixin2
     implements
@@ -957,7 +950,6 @@ mixin ConstructorElementMixin2
 
 /// A concrete implementation of a [ConstructorFragment].
 class ConstructorFragmentImpl extends ExecutableFragmentImpl
-    with ConstructorElementMixin
     implements ConstructorFragment {
   late final ConstructorElementImpl element;
 
@@ -1033,7 +1025,7 @@ class ConstructorFragmentImpl extends ExecutableFragmentImpl
   InstanceFragment? get enclosingFragment =>
       enclosingElement3 as InstanceFragment;
 
-  @override
+  /// Whether the constructor is a const constructor.
   bool get isConst {
     return hasModifier(Modifier.CONST);
   }
@@ -1043,7 +1035,8 @@ class ConstructorFragmentImpl extends ExecutableFragmentImpl
     setModifier(Modifier.CONST, isConst);
   }
 
-  @override
+  /// Whether the constructor can be used as a default constructor - unnamed,
+  /// and has no required parameters.
   bool get isDefaultConstructor {
     // unnamed
     if (name2 != 'new') {
@@ -1059,7 +1052,7 @@ class ConstructorFragmentImpl extends ExecutableFragmentImpl
     return true;
   }
 
-  @override
+  /// Whether the constructor represents a factory constructor.
   bool get isFactory {
     return hasModifier(Modifier.FACTORY);
   }
@@ -1069,7 +1062,7 @@ class ConstructorFragmentImpl extends ExecutableFragmentImpl
     setModifier(Modifier.FACTORY, isFactory);
   }
 
-  @override
+  /// Whether the constructor represents a generative constructor.
   bool get isGenerative {
     return !isFactory;
   }
@@ -1119,7 +1112,7 @@ class ConstructorFragmentImpl extends ExecutableFragmentImpl
 
   @override
   void appendTo(ElementDisplayStringBuilder builder) {
-    builder.writeConstructorElement(this);
+    builder.writeConstructorFragment(this);
   }
 
   /// Ensures that dependencies of this constructor, such as default values

pkg/analyzer/lib/src/dart/element/member.dart

@@ -20,7 +20,7 @@ import 'package:pub_semver/pub_semver.dart';
 /// A constructor element defined in a parameterized type where the values of
 /// the type parameters are known.
 class ConstructorMember extends ExecutableMember
-    with ConstructorElementMixin, ConstructorElementMixin2
+    with ConstructorElementMixin2
     implements ConstructorElement {
   /// Initialize a newly created element to represent a constructor, based on
   /// the [declaration], and applied [substitution].
@@ -143,25 +143,6 @@ class ConstructorMember extends ExecutableMember
     }
   }
 
-  /// If the given [element]'s type is different when any type parameters
-  /// from the defining type's declaration are replaced with the actual type
-  /// arguments from the [definingType], create a constructor member
-  /// representing the given constructor. Return the member that was created, or
-  /// the original constructor if no member was created.
-  static ConstructorElementMixin from(
-    ConstructorFragmentImpl element,
-    InterfaceType definingType,
-  ) {
-    if (definingType.typeArguments.isEmpty) {
-      return element;
-    }
-
-    return ConstructorMember(
-      declaration: element,
-      substitution: Substitution.fromInterfaceType(definingType),
-    );
-  }
-
   /// If the given [element]'s type is different when any type parameters
   /// from the defining type's declaration are replaced with the actual type
   /// arguments from the [definingType], create a constructor member

pkg/analyzer/lib/src/utilities/extensions/element.dart

@@ -90,25 +90,6 @@ extension ConstructorElementImplExtension on ConstructorFragmentImpl {
   }
 }
 
-extension ConstructorElementMixin2Extension on ConstructorElementMixin2 {
-  ConstructorElementMixin get asElement {
-    if (this case ConstructorMember member) {
-      return member;
-    }
-    return (this as ConstructorElementImpl).lastFragment;
-  }
-}
-
-extension ConstructorElementMixinExtension on ConstructorElementMixin {
-  ConstructorElementMixin2 get asElement2 {
-    return switch (this) {
-      ConstructorFragmentImpl(:var element) => element,
-      ConstructorMember member => member,
-      _ => throw UnsupportedError('Unsupported type: $runtimeType'),
-    };
-  }
-}
-
 extension Element2Extension on Element {
   /// Whether the element is effectively [internal].
   bool get isInternal {