Remove unsafe uses of TypeImpl.withNullability (use TypeSystem instead).

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

Author: stereotype441

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

@@ -2958,6 +2958,12 @@ abstract class TypeImpl implements DartType {
    *
    * If the nullability of `this` already matches [nullabilitySuffix], `this`
    * is returned.
+   *
+   * Note: this method just does low-level manipulations of the underlying type,
+   * so it is what you want if you are constructing a fresh type and want it to
+   * have the correct nullability suffix, but it is generally *not* what you
+   * want if you're manipulating existing types.  For manipulating existing
+   * types, please use the methods in [TypeSystem].
    */
   TypeImpl withNullability(NullabilitySuffix nullabilitySuffix);
 

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

@@ -778,9 +778,7 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
     TypeImpl staticType = _getStaticType(operand, read: true);
 
     if (node.operator.type == TokenType.BANG) {
-      // TODO(paulberry): This does the wrong thing if staticType is a type
-      // parameter type.
-      staticType = staticType.withNullability(NullabilitySuffix.none);
+      staticType = _typeSystem.promoteToNonNull(staticType);
     } else {
       // No need to check for `intVar++`, the result is `int`.
       if (!staticType.isDartCoreInt) {
@@ -916,8 +914,7 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
 
     if (node.operator.type == TokenType.QUESTION_PERIOD &&
         _nonNullableEnabled) {
-      staticType =
-          (staticType as TypeImpl).withNullability(NullabilitySuffix.question);
+      staticType = _typeSystem.makeNullable(staticType);
     }
     staticType = _inferGenericInstantiationFromContext(node, staticType);
 
@@ -1235,22 +1232,24 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
    * Compute the return type of the method or function represented by the given
    * type that is being invoked.
    */
-  DartType _computeInvokeReturnType(DartType type,
+  DartType /*!*/ _computeInvokeReturnType(DartType type,
       {@required bool isNullableInvoke}) {
-    TypeImpl returnType;
+    TypeImpl /*!*/ returnType;
     if (type is InterfaceType) {
       MethodElement callMethod = type.lookUpMethod(
           FunctionElement.CALL_METHOD_NAME, _resolver.definingLibrary);
-      returnType = callMethod?.type?.returnType;
+      returnType = callMethod?.type?.returnType ?? _dynamicType;
     } else if (type is FunctionType) {
-      returnType = type.returnType;
+      returnType = type.returnType ?? _dynamicType;
+    } else {
+      returnType = _dynamicType;
     }
 
     if (isNullableInvoke && _nonNullableEnabled) {
-      returnType = returnType?.withNullability(NullabilitySuffix.question);
+      returnType = _typeSystem.makeNullable(returnType);
     }
 
-    return returnType ?? _dynamicType;
+    return returnType;
   }
 
   /**

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

@@ -2046,6 +2046,13 @@ abstract class TypeSystem implements public.TypeSystem {
     return getLeastUpperBound(leftType, rightType);
   }
 
+  /// Returns a nullable version of [type].  The result would be equivalent to
+  /// the union `type | Null` (if we supported union types).
+  DartType makeNullable(TypeImpl type) {
+    // TODO(paulberry): handle type parameter types
+    return type.withNullability(NullabilitySuffix.question);
+  }
+
   /// Attempts to find the appropriate substitution for [typeParameters] that can
   /// be applied to [src] to make it equal to [dest].  If no such substitution can
   /// be found, `null` is returned.