[flow_analysis] Don't promote on invalid type

Flow analysis didn't handle invalid type so non-null promotion would occur on declaration and initialization on erroneous code, leading to warnings about null-aware that is likely valid. For instance

    f(Unresolved o) { // Error: Unresolved is unresolved
      int? i = o.property;
      i?.isEven; // Warning about unnecessary null-aware access
      if (i != null) { // Warning about unnecessary null comparison
        i.isEven;
      }
    }

To handle this fully we need to track invalid nullability (if that is even feasible) but for now we change the default to avoid non-null promotion in such cases.

This *does* change the kind cascading errors/warnings that we produce. For instance

    f(Unresolved o) { // Error: Unresolved is unresolved
      int? i = o.nonNullProperty;
      i.isEven; // Error for access on int?
    }

but since it probably more likely for code to *not* depend on non-null promotion, this should be less noise for the user.

Change-Id: Ia2bc3505a43b52e5151b93a7fee24e95246b4bbc
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/443320
Reviewed-by: Brian Wilkerson <[email protected]>
Reviewed-by: Paul Berry <[email protected]>
Commit-Queue: Johnni Winther <[email protected]>

Author: johnniwinther

pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart

@@ -4034,6 +4034,11 @@ class PromotionModel<Type extends Object> {
     List<Type>? candidates = null;
 
     void handleTypeOfInterest(Type type) {
+      // If the written type is invalid, we assume no promotion.
+      if (helper.typeOperations.isInvalidType(writtenType)) {
+        return;
+      }
+
       // The written type must be a subtype of the type.
       if (!helper.typeOperations.isSubtypeOf(writtenType, type)) {
         return;

pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis_operations.dart

@@ -88,6 +88,10 @@ abstract interface class FlowAnalysisTypeOperations<Type extends Object> {
   /// Returns `true` if [type] is a reference to a type parameter.
   bool isTypeParameterType(Type type);
 
+  /// Returns `true` if [type] represents the invalid type, i.e. the type of
+  /// an invalid expression.
+  bool isInvalidType(Type type);
+
   /// Computes the nullable form of [type], in other words the least upper bound
   /// of [type] and `Null`.
   ///

pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_test.dart

@@ -12639,6 +12639,28 @@ main() {
         ]);
       });
 
+      test('Invalid type does not promote on assignment', () {
+        // Declared type is `num?`; assigning an invalid type does not promote
+        // to `num`.
+        var x = Var('x');
+        h.run([
+          declare(x, initializer: expr('num?')),
+          checkNotPromoted(x),
+          x.write(expr('error')),
+          checkNotPromoted(x),
+        ]);
+      });
+
+      test('Invalid type does not promote on declaration', () {
+        // Declared type is `num?`; initializing an invalid type does not
+        // promote to `num`.
+        var x = Var('x');
+        h.run([
+          declare(x, type: 'num?', initializer: expr('error')),
+          checkNotPromoted(x),
+        ]);
+      });
+
       test('Untested type is not a type of interest', () {
         // Declared type is `Object`; assigning an `int` does not promote.
         var x = Var('x');

pkg/_fe_analyzer_shared/test/flow_analysis/type_promotion/data/invalid.dart

@@ -0,0 +1,15 @@
+// Copyright (c) 2025, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+method1(Unresolved? o) {
+  int? a = o.foo;
+  a;
+}
+
+method2(Unresolved? o) {
+  int? a;
+  a;
+  a = o.foo;
+  a;
+}

pkg/_fe_analyzer_shared/test/mini_ast.dart

@@ -3298,6 +3298,11 @@ class MiniAstOperations
     return type is PrimaryType && type.isInterfaceType;
   }
 
+  @override
+  bool isInvalidType(SharedTypeView type) {
+    return type is InvalidType;
+  }
+
   @override
   bool isKnownType(SharedTypeSchemaView typeSchema) {
     var unwrapped = typeSchema.unwrapTypeSchemaView<Type>();

pkg/_fe_analyzer_shared/test/mini_types.dart

@@ -1285,6 +1285,11 @@ class TypeSystem {
     //   types with a single name and no type arguments (this covers both
     //   primitive types and type variables).
     switch ((t0, t1)) {
+      case (InvalidType(), _):
+      case (_, InvalidType()):
+        // `InvalidType` is treated as a top and a bottom type, which is
+        // consistent with CFE and analyzer implementations.
+        return true;
       case (
             PrimaryType(nameInfo: var t0Info, isQuestionType: false, args: []),
             PrimaryType(nameInfo: var t1Info, isQuestionType: false, args: []),
@@ -1316,7 +1321,7 @@ class TypeSystem {
     if (_isTop(t1)) return true;
 
     // Left Top: if T0 is dynamic or void then T0 <: T1 if Object? <: T1
-    if (t0 is DynamicType || t0 is InvalidType || t0 is VoidType) {
+    if (t0 is DynamicType || t0 is VoidType) {
       return isSubtype(_objectQuestionType, t1);
     }
 
@@ -1355,7 +1360,6 @@ class TypeSystem {
       //   false).
       if (t0 is NullType ||
           t0 is DynamicType ||
-          t0 is InvalidType ||
           t0 is VoidType ||
           t0.isQuestionType) {
         return false;

pkg/analyzer/lib/src/dart/resolver/flow_analysis_visitor.dart

@@ -664,6 +664,11 @@ class TypeSystemOperations
         type.element is! ExtensionTypeElement;
   }
 
+  @override
+  bool isInvalidType(SharedTypeView type) {
+    return type.unwrapTypeView<TypeImpl>() is InvalidType;
+  }
+
   @override
   bool isKnownType(SharedTypeSchemaView typeSchema) {
     return UnknownInferredType.isKnown(

pkg/analyzer/test/id_tests/type_promotion_test.dart

@@ -39,6 +39,9 @@ class _TypePromotionDataComputer extends DataComputer<DartType> {
   DataInterpreter<DartType> get dataValidator =>
       const _TypePromotionDataInterpreter();
 
+  @override
+  bool get supportsErrors => true;
+
   @override
   void computeUnitData(
     TestingData testingData,

pkg/analyzer/test/src/diagnostics/invalid_null_aware_operator_test.dart

@@ -326,6 +326,37 @@ f(List<int>? x) {
 ''');
   }
 
+  test_invalid_nonNullable() async {
+    await assertErrorsInCode(
+      '''
+f(Unresolved o) {
+  int? i = o.nonNull;
+  i.isEven;
+}
+''',
+      [
+        error(CompileTimeErrorCode.UNDEFINED_CLASS, 2, 10),
+        error(
+          CompileTimeErrorCode.UNCHECKED_PROPERTY_ACCESS_OF_NULLABLE_VALUE,
+          44,
+          6,
+        ),
+      ],
+    );
+  }
+
+  test_invalid_nullable() async {
+    await assertErrorsInCode(
+      '''
+f(Unresolved o) {
+  int? i = o.nullable;
+  i?.isEven;
+}
+''',
+      [error(CompileTimeErrorCode.UNDEFINED_CLASS, 2, 10)],
+    );
+  }
+
   test_method_class() async {
     await assertErrorsInCode(
       '''

pkg/analyzer/test/src/diagnostics/unnecessary_null_comparison_test.dart

@@ -86,6 +86,32 @@ f() {
 
 @reflectiveTest
 class UnnecessaryNullComparisonTrueTest extends PubPackageResolutionTest {
+  test_equal_invalid_nonNull() async {
+    await assertErrorsInCode(
+      '''
+f(Unresolved o) {
+  int? i = o.nonNull;
+  i == null;
+  null == i;
+}
+''',
+      [error(CompileTimeErrorCode.UNDEFINED_CLASS, 2, 10)],
+    );
+  }
+
+  test_equal_invalid_nullable() async {
+    await assertErrorsInCode(
+      '''
+f(Unresolved o) {
+  int? i = o.nullable;
+  i == null;
+  null == i;
+}
+''',
+      [error(CompileTimeErrorCode.UNDEFINED_CLASS, 2, 10)],
+    );
+  }
+
   test_notEqual_intLiteral() async {
     await assertNoErrorsInCode('''
 f(int a, int? b) {
@@ -97,6 +123,32 @@ f(int a, int? b) {
 ''');
   }
 
+  test_notEqual_invalid_nonNull() async {
+    await assertErrorsInCode(
+      '''
+f(Unresolved o) {
+  int? i = o.nonNull;
+  i != null;
+  null != i;
+}
+''',
+      [error(CompileTimeErrorCode.UNDEFINED_CLASS, 2, 10)],
+    );
+  }
+
+  test_notEqual_invalid_nullable() async {
+    await assertErrorsInCode(
+      '''
+f(Unresolved o) {
+  int? i = o.nullable;
+  i != null;
+  null != i;
+}
+''',
+      [error(CompileTimeErrorCode.UNDEFINED_CLASS, 2, 10)],
+    );
+  }
+
   test_notEqual_notNullable() async {
     await assertErrorsInCode(
       '''