Issue 40413. Don't infer promoted TypeParameterType(s) for locals.

Internal presubmit looks green.
https://test.corp.google.com/ui#id=OCL:295832949:BASE:295984425:1582132722046:8eaca57b

Bug: #40413
Change-Id: I8514f6e1a99c4b02098cc649607cf31c5daf350f
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/136360
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

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

@@ -0,0 +1,122 @@
+// Copyright (c) 2020, 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.md file.
+
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/nullability_suffix.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/element/replacement_visitor.dart';
+import 'package:analyzer/src/dart/element/type.dart';
+import 'package:analyzer/src/dart/element/type_visitor.dart';
+
+/// Returns [type] in which all promoted type variables have been replace with
+/// their unpromoted equivalents, and, if [library] is non-nullable by default,
+/// replaces all legacy types with their non-nullable equivalents.
+DartType demoteType(LibraryElement library, DartType type) {
+  if (library.isNonNullableByDefault) {
+    var visitor = const _DemotionNonNullification();
+    return visitor.visit(type) ?? type;
+  } else {
+    var visitor = const _DemotionNonNullification(nonNullifyTypes: false);
+    return visitor.visit(type) ?? type;
+  }
+}
+
+/// Returns `true` if type contains a promoted type variable.
+bool hasPromotedTypeVariable(DartType type) {
+  return const _HasPromotedTypeVariableVisitor()._visit(type);
+}
+
+/// Returns [type] in which all legacy types have been replaced with
+/// non-nullable types.
+DartType nonNullifyType(LibraryElement library, DartType type) {
+  if (library.isNonNullableByDefault) {
+    var visitor = const _DemotionNonNullification(demoteTypeVariables: false);
+    return visitor.visit(type) ?? type;
+  }
+  return type;
+}
+
+/// Visitor that replaces all promoted type variables the type variable itself
+/// and/or replaces all legacy types with non-nullable types.
+///
+/// The visitor returns `null` if the type wasn't changed.
+class _DemotionNonNullification extends ReplacementVisitor {
+  final bool demoteTypeVariables;
+  final bool nonNullifyTypes;
+
+  const _DemotionNonNullification({
+    this.demoteTypeVariables = true,
+    this.nonNullifyTypes = true,
+  }) : assert(demoteTypeVariables || nonNullifyTypes);
+
+  @override
+  NullabilitySuffix visitNullability(DartType type) {
+    if (nonNullifyTypes && type.nullabilitySuffix == NullabilitySuffix.star) {
+      return NullabilitySuffix.none;
+    }
+    return null;
+  }
+
+  @override
+  DartType visitTypeParameterType(TypeParameterType type) {
+    var newNullability = visitNullability(type);
+
+    if (demoteTypeVariables) {
+      var typeImpl = type as TypeParameterTypeImpl;
+      if (typeImpl.promotedBound != null) {
+        return TypeParameterTypeImpl(
+          element: type.element,
+          nullabilitySuffix: newNullability ?? type.nullabilitySuffix,
+        );
+      }
+    }
+
+    return createTypeParameterType(
+      type: type,
+      newNullability: newNullability,
+    );
+  }
+}
+
+/// Visitor that returns `true` if a type contains a promoted type variable.
+class _HasPromotedTypeVariableVisitor extends DartTypeVisitor<bool> {
+  const _HasPromotedTypeVariableVisitor();
+
+  @override
+  bool defaultDartType(DartType type) => false;
+
+  @override
+  bool visitFunctionType(FunctionType type) {
+    if (_visit(type.returnType)) {
+      return true;
+    }
+
+    for (var parameter in type.parameters) {
+      if (_visit(parameter.type)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  @override
+  bool visitInterfaceType(InterfaceType type) {
+    for (var typeArgument in type.typeArguments) {
+      if (_visit(typeArgument)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @override
+  bool visitTypeParameterType(TypeParameterType type) {
+    return (type as TypeParameterTypeImpl).promotedBound != null;
+  }
+
+  bool _visit(DartType type) {
+    return DartTypeVisitor.visit(type, this);
+  }
+}

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

@@ -12,6 +12,7 @@ import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/member.dart' show ConstructorMember;
 import 'package:analyzer/src/dart/element/type.dart';
+import 'package:analyzer/src/dart/element/type_demotion.dart';
 import 'package:analyzer/src/dart/element/type_provider.dart';
 import 'package:analyzer/src/dart/resolver/flow_analysis_visitor.dart';
 import 'package:analyzer/src/error/codes.dart';
@@ -985,7 +986,12 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
         if (type != null && !type.isBottom && !type.isDartCoreNull) {
           VariableElement element = node.declaredElement;
           if (element is LocalVariableElementImpl) {
-            element.type = initializer.staticType;
+            var initializerType = initializer.staticType;
+            var inferredType = demoteType(
+              _resolver.definingLibrary,
+              initializerType,
+            );
+            element.type = inferredType;
           }
         }
       }

pkg/analyzer/test/src/dart/resolution/type_inference/local_variable_test.dart

@@ -0,0 +1,41 @@
+// Copyright (c) 2020, 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.
+
+import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/element/type.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../driver_resolution.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(LocalVariableTest);
+  });
+}
+
+@reflectiveTest
+class LocalVariableTest extends DriverResolutionTest {
+  void assertPromotedBound(DartType type, Matcher promotedBound) {
+    if (type is TypeParameterTypeImpl) {
+      expect(type.promotedBound, promotedBound);
+    }
+  }
+
+  test_demoteTypeParameterType() async {
+    await assertNoErrorsInCode('''
+void f<T>(T a, T b) {
+  if (a is String) {
+    var o = a;
+    o = b;
+    o; // ref
+  }
+}
+''');
+
+    var type = findNode.simple('o; // ref').staticType;
+    assertType(type, 'T');
+    assertPromotedBound(type, isNull);
+  }
+}

pkg/analyzer/test/src/dart/resolution/type_inference/test_all.dart

@@ -10,6 +10,7 @@ import 'equality_expressions_test.dart' as equality_expressions;
 import 'extension_methods_test.dart' as extension_methods;
 import 'function_expression_test.dart' as function_expression;
 import 'list_literal_test.dart' as list_literal;
+import 'local_variable_test.dart' as local_variable;
 import 'logical_boolean_expressions_test.dart' as logical_boolean_expressions;
 import 'map_literal_test.dart' as map_literal;
 import 'set_literal_test.dart' as set_literal;
@@ -26,6 +27,7 @@ main() {
     extension_methods.main();
     function_expression.main();
     list_literal.main();
+    local_variable.main();
     logical_boolean_expressions.main();
     map_literal.main();
     set_literal.main();

pkg/analyzer/test/src/task/strong/checker_test.dart

@@ -4603,7 +4603,7 @@ void f<T extends num>(T x, T y) {
     // This captures the type `T extends int`.
     var g = () => x;
     g = f;
-    g().isEven;
+    g()./*error:UNDEFINED_GETTER*/isEven;
     q = g();
     int r = x;
   }