Restore skipping all dynamic type arguments in DartType.displayName

There is one internal client that currently depends on such presentation.
This will unblock rolling analyzer, then we will fix the client, and
remove this skipping code in analyzer.

R=brianwilkerson@google.com, paulberry@google.com

Change-Id: I0d6387892d12326d658800069dd8a60faa589405
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/127488
Reviewed-by: Paul Berry <paulberry@google.com>
Commit-Queue: Konstantin Shcheglov <scheglov@google.com>

Author: scheglov

pkg/analyzer/lib/error/listener.dart

@@ -202,7 +202,11 @@ class ErrorReporter {
         if (name != null && name.isNotEmpty) {
           StringBuffer buffer = StringBuffer();
           buffer.write(name);
-          (type as TypeImpl).appendTo(buffer, withNullability: false);
+          (type as TypeImpl).appendTo(
+            buffer,
+            withNullability: false,
+            skipAllDynamicArguments: false,
+          );
           return buffer.toString();
         }
       }

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

@@ -4634,7 +4634,11 @@ class GenericFunctionTypeElementImpl extends ElementImpl
   void appendTo(StringBuffer buffer) {
     DartType type = returnType;
     if (type is TypeImpl) {
-      type.appendTo(buffer, withNullability: false);
+      type.appendTo(
+        buffer,
+        withNullability: false,
+        skipAllDynamicArguments: false,
+      );
       buffer.write(' Function');
     } else {
       buffer.write('Function');

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

@@ -65,7 +65,11 @@ class DynamicTypeImpl extends TypeImpl {
   bool operator ==(Object object) => identical(object, this);
 
   @override
-  void appendTo(StringBuffer buffer, {@required bool withNullability}) {
+  void appendTo(
+    StringBuffer buffer, {
+    @required bool withNullability,
+    @required bool skipAllDynamicArguments,
+  }) {
     buffer.write('dynamic');
   }
 
@@ -255,7 +259,11 @@ class FunctionTypeImpl extends TypeImpl implements FunctionType {
   }
 
   @override
-  void appendTo(StringBuffer buffer, {@required bool withNullability}) {
+  void appendTo(
+    StringBuffer buffer, {
+    @required bool withNullability,
+    @required bool skipAllDynamicArguments,
+  }) {
     if (typeFormals.isNotEmpty) {
       StringBuffer typeParametersBuffer = StringBuffer();
       // To print a type with type variables, first make sure we have unique
@@ -296,25 +304,41 @@ class FunctionTypeImpl extends TypeImpl implements FunctionType {
         TypeParameterTypeImpl t = TypeParameterTypeImpl(
             TypeParameterElementImpl(name, -1),
             nullabilitySuffix: NullabilitySuffix.none);
-        t.appendTo(typeParametersBuffer, withNullability: withNullability);
+        t.appendTo(
+          typeParametersBuffer,
+          withNullability: withNullability,
+          skipAllDynamicArguments: skipAllDynamicArguments,
+        );
         instantiateTypeArgs.add(t);
         variables.add(e);
         if (e.bound != null) {
           typeParametersBuffer.write(' extends ');
           TypeImpl renamed =
               Substitution.fromPairs(variables, instantiateTypeArgs)
                   .substituteType(e.bound);
-          renamed.appendTo(typeParametersBuffer,
-              withNullability: withNullability);
+          renamed.appendTo(
+            typeParametersBuffer,
+            withNullability: withNullability,
+            skipAllDynamicArguments: skipAllDynamicArguments,
+          );
         }
       }
       typeParametersBuffer.write('>');
 
       // Instantiate it and print the resulting type.
       this.instantiate(instantiateTypeArgs)._appendToWithTypeParameters(
-          buffer, withNullability, typeParametersBuffer.toString());
+            buffer,
+            typeParametersBuffer.toString(),
+            withNullability: withNullability,
+            skipAllDynamicArguments: skipAllDynamicArguments,
+          );
     } else {
-      _appendToWithTypeParameters(buffer, withNullability, '');
+      _appendToWithTypeParameters(
+        buffer,
+        '',
+        withNullability: withNullability,
+        skipAllDynamicArguments: skipAllDynamicArguments,
+      );
     }
   }
 
@@ -415,16 +439,23 @@ class FunctionTypeImpl extends TypeImpl implements FunctionType {
   }
 
   void _appendToWithTypeParameters(
-      StringBuffer buffer, bool withNullability, String typeParameters) {
+    StringBuffer buffer,
+    String typeParameters, {
+    @required bool withNullability,
+    @required bool skipAllDynamicArguments,
+  }) {
     List<DartType> normalParameterTypes = this.normalParameterTypes;
     List<DartType> optionalParameterTypes = this.optionalParameterTypes;
     DartType returnType = this.returnType;
 
     if (returnType == null) {
       buffer.write('null');
     } else {
-      (returnType as TypeImpl)
-          .appendTo(buffer, withNullability: withNullability);
+      (returnType as TypeImpl).appendTo(
+        buffer,
+        withNullability: withNullability,
+        skipAllDynamicArguments: skipAllDynamicArguments,
+      );
     }
     buffer.write(' Function');
     buffer.write(typeParameters);
@@ -449,15 +480,23 @@ class FunctionTypeImpl extends TypeImpl implements FunctionType {
     if (normalParameterTypes.isNotEmpty) {
       for (DartType type in normalParameterTypes) {
         writeSeparator();
-        (type as TypeImpl).appendTo(buffer, withNullability: withNullability);
+        (type as TypeImpl).appendTo(
+          buffer,
+          withNullability: withNullability,
+          skipAllDynamicArguments: skipAllDynamicArguments,
+        );
       }
     }
     if (optionalParameterTypes.isNotEmpty) {
       startOptionalParameters();
       buffer.write('[');
       for (DartType type in optionalParameterTypes) {
         writeSeparator();
-        (type as TypeImpl).appendTo(buffer, withNullability: withNullability);
+        (type as TypeImpl).appendTo(
+          buffer,
+          withNullability: withNullability,
+          skipAllDynamicArguments: skipAllDynamicArguments,
+        );
       }
       buffer.write(']');
       needsComma = true;
@@ -474,8 +513,11 @@ class FunctionTypeImpl extends TypeImpl implements FunctionType {
         }
         buffer.write(parameter.name);
         buffer.write(': ');
-        (parameter.type as TypeImpl)
-            .appendTo(buffer, withNullability: withNullability);
+        (parameter.type as TypeImpl).appendTo(
+          buffer,
+          withNullability: withNullability,
+          skipAllDynamicArguments: skipAllDynamicArguments,
+        );
       }
       buffer.write('}');
       needsComma = true;
@@ -1099,17 +1141,33 @@ class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
   }
 
   @override
-  void appendTo(StringBuffer buffer, {@required bool withNullability}) {
+  void appendTo(
+    StringBuffer buffer, {
+    @required bool withNullability,
+    @required bool skipAllDynamicArguments,
+  }) {
     buffer.write(element.name);
+
     int argumentCount = typeArguments.length;
-    if (argumentCount > 0) {
+
+    bool includeTypeArguments;
+    if (skipAllDynamicArguments) {
+      includeTypeArguments = typeArguments.any((t) => !t.isDynamic);
+    } else {
+      includeTypeArguments = argumentCount > 0;
+    }
+
+    if (includeTypeArguments) {
       buffer.write("<");
       for (int i = 0; i < argumentCount; i++) {
         if (i > 0) {
           buffer.write(", ");
         }
-        (typeArguments[i] as TypeImpl)
-            .appendTo(buffer, withNullability: withNullability);
+        (typeArguments[i] as TypeImpl).appendTo(
+          buffer,
+          withNullability: withNullability,
+          skipAllDynamicArguments: skipAllDynamicArguments,
+        );
       }
       buffer.write(">");
     }
@@ -1825,7 +1883,11 @@ class NeverTypeImpl extends TypeImpl {
   bool operator ==(Object object) => identical(object, this);
 
   @override
-  void appendTo(StringBuffer buffer, {@required bool withNullability}) {
+  void appendTo(
+    StringBuffer buffer, {
+    @required bool withNullability,
+    @required bool skipAllDynamicArguments,
+  }) {
     buffer.write('Never');
     if (withNullability) {
       _appendNullability(buffer);
@@ -1892,9 +1954,13 @@ abstract class TypeImpl implements DartType {
    */
   TypeImpl(this._element, this.name);
 
+  @deprecated
   @override
   String get displayName {
-    return getDisplayString(withNullability: false);
+    return getDisplayString(
+      withNullability: false,
+      skipAllDynamicArguments: true,
+    );
   }
 
   @override
@@ -1960,12 +2026,23 @@ abstract class TypeImpl implements DartType {
   /**
    * Append a textual representation of this type to the given [buffer].
    */
-  void appendTo(StringBuffer buffer, {@required bool withNullability});
+  void appendTo(
+    StringBuffer buffer, {
+    @required bool withNullability,
+    @required bool skipAllDynamicArguments,
+  });
 
   @override
-  String getDisplayString({bool withNullability = false}) {
+  String getDisplayString({
+    bool withNullability = false,
+    bool skipAllDynamicArguments = false,
+  }) {
     var buffer = StringBuffer();
-    appendTo(buffer, withNullability: withNullability);
+    appendTo(
+      buffer,
+      withNullability: withNullability,
+      skipAllDynamicArguments: skipAllDynamicArguments,
+    );
     return buffer.toString();
   }
 
@@ -2105,7 +2182,11 @@ class TypeParameterTypeImpl extends TypeImpl implements TypeParameterType {
   }
 
   @override
-  void appendTo(StringBuffer buffer, {@required bool withNullability}) {
+  void appendTo(
+    StringBuffer buffer, {
+    @required bool withNullability,
+    @required bool skipAllDynamicArguments,
+  }) {
     buffer.write(element.name);
     if (withNullability) {
       _appendNullability(buffer);
@@ -2251,7 +2332,11 @@ class VoidTypeImpl extends TypeImpl implements VoidType {
   bool operator ==(Object object) => identical(object, this);
 
   @override
-  void appendTo(StringBuffer buffer, {@required bool withNullability}) {
+  void appendTo(
+    StringBuffer buffer, {
+    @required bool withNullability,
+    @required bool skipAllDynamicArguments,
+  }) {
     buffer.write('void');
   }
 

pkg/analyzer/lib/src/generated/element_resolver.dart

@@ -1683,7 +1683,7 @@ class ElementResolver extends SimpleAstVisitor<void> {
               _resolver.errorReporter.reportErrorForNode(
                 StaticTypeWarningCode.UNDEFINED_SUPER_GETTER,
                 propertyName,
-                [propertyName.name, staticType.displayName],
+                [propertyName.name, staticType],
               );
             }
           }
@@ -1719,7 +1719,7 @@ class ElementResolver extends SimpleAstVisitor<void> {
               _resolver.errorReporter.reportErrorForNode(
                 StaticTypeWarningCode.UNDEFINED_SUPER_SETTER,
                 propertyName,
-                [propertyName.name, staticType.displayName],
+                [propertyName.name, staticType],
               );
             }
           }

pkg/analyzer/lib/src/generated/type_system.dart

@@ -3798,7 +3798,11 @@ class UnknownInferredType extends TypeImpl {
   bool operator ==(Object object) => identical(object, this);
 
   @override
-  void appendTo(StringBuffer buffer, {bool withNullability = false}) {
+  void appendTo(
+    StringBuffer buffer, {
+    bool withNullability = false,
+    @required bool skipAllDynamicArguments,
+  }) {
     buffer.write('?');
   }
 

pkg/analyzer/test/generated/static_type_analyzer_test.dart

@@ -1295,7 +1295,7 @@ class StaticTypeAnalyzerTest with ResourceProviderMixin, ElementsTypesMixin {
 
   void _assertType(
       InterfaceTypeImpl expectedType, InterfaceTypeImpl actualType) {
-    expect(actualType.displayName, expectedType.displayName);
+    expect(actualType.getDisplayString(), expectedType.getDisplayString());
     expect(actualType.element, expectedType.element);
     List<DartType> expectedArguments = expectedType.typeArguments;
     int length = expectedArguments.length;