Flow analysis: improve handling of types in "why not promoted" logic.

This CL plumbs the types of `this` and property get expression from
the CFE and analyzer into flow analysis, so that flow analysis will be
able to create more accurate "why not promoted" information for those
expression types.  This made it possible to eliminate a clumsy aspect
of the previous implementation, namely that we would consider a
promotion attempt like `if (x.y == null) return;` as an attempt to
promote the type of `x.y` to `Object`; now we compute the type the
user is actually trying to promote to, so we will be able to generate
more accurate "why not promoted" messages.

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

Author: stereotype441

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

@@ -144,9 +144,9 @@ Statement if_(Expression condition, List<Statement> ifTrue,
         [List<Statement>? ifFalse]) =>
     new _If(condition, ifTrue, ifFalse);
 
-Statement implicitThis_whyNotPromoted(
+Statement implicitThis_whyNotPromoted(String staticType,
         void Function(Map<Type, NonPromotionReason>) callback) =>
-    new _WhyNotPromoted_ImplicitThis(callback);
+    new _WhyNotPromoted_ImplicitThis(Type(staticType), callback);
 
 Statement labeled(Statement body) => new _LabeledStatement(body);
 
@@ -161,7 +161,7 @@ Statement switch_(Expression expression, List<SwitchCase> cases,
 Expression this_(String type) => new _This(Type(type));
 
 Expression thisOrSuperPropertyGet(String name, {String type = 'Object?'}) =>
-    new _ThisOrSuperPropertyGet(name, type);
+    new _ThisOrSuperPropertyGet(name, Type(type));
 
 Expression throw_(Expression operand) => new _Throw(operand);
 
@@ -284,7 +284,7 @@ abstract class Expression extends Node implements _Visitable<Type> {
 
   /// If `this` is an expression `x`, creates the expression `x.name`.
   Expression propertyGet(String name, {String type = 'Object?'}) =>
-      new _PropertyGet(this, name, type);
+      new _PropertyGet(this, name, Type(type));
 
   /// If `this` is an expression `x`, creates a pseudo-expression that models
   /// evaluation of `x` followed by execution of [stmt].  This can be used to
@@ -435,9 +435,6 @@ class Harness extends TypeOperations<Var, Type> {
 
   Harness({this.legacy = false});
 
-  @override
-  Type get topType => Type('Object?');
-
   /// Updates the harness so that when a [factor] query is invoked on types
   /// [from] and [what], [result] will be returned.
   void addFactor(String from, String what, String result) {
@@ -1477,7 +1474,7 @@ class _PropertyGet extends Expression {
 
   final String propertyName;
 
-  final String type;
+  final Type type;
 
   _PropertyGet(this.target, this.propertyName, this.type);
 
@@ -1490,8 +1487,8 @@ class _PropertyGet extends Expression {
   Type _visit(
       Harness h, FlowAnalysis<Node, Statement, Expression, Var, Type> flow) {
     target._visit(h, flow);
-    flow.propertyGet(this, target, propertyName);
-    return Type(type);
+    flow.propertyGet(this, target, propertyName, type);
+    return type;
   }
 }
 
@@ -1566,15 +1563,15 @@ class _This extends Expression {
   @override
   Type _visit(
       Harness h, FlowAnalysis<Node, Statement, Expression, Var, Type> flow) {
-    flow.thisOrSuper(this);
+    flow.thisOrSuper(this, type);
     return type;
   }
 }
 
 class _ThisOrSuperPropertyGet extends Expression {
   final String propertyName;
 
-  final String type;
+  final Type type;
 
   _ThisOrSuperPropertyGet(this.propertyName, this.type);
 
@@ -1584,8 +1581,8 @@ class _ThisOrSuperPropertyGet extends Expression {
   @override
   Type _visit(
       Harness h, FlowAnalysis<Node, Statement, Expression, Var, Type> flow) {
-    flow.thisOrSuperPropertyGet(this, propertyName);
-    return Type(type);
+    flow.thisOrSuperPropertyGet(this, propertyName, type);
+    return type;
   }
 }
 
@@ -1760,9 +1757,11 @@ class _WhyNotPromoted extends Expression {
 }
 
 class _WhyNotPromoted_ImplicitThis extends Statement {
+  final Type staticType;
+
   final void Function(Map<Type, NonPromotionReason>) callback;
 
-  _WhyNotPromoted_ImplicitThis(this.callback) : super._();
+  _WhyNotPromoted_ImplicitThis(this.staticType, this.callback) : super._();
 
   @override
   String toString() => 'implicit this (whyNotPromoted)';
@@ -1776,7 +1775,7 @@ class _WhyNotPromoted_ImplicitThis extends Statement {
     assert(!Type._allowComparisons);
     Type._allowComparisons = true;
     try {
-      callback(flow.whyNotPromoted(null));
+      callback(flow.whyNotPromotedImplicitThis(staticType));
     } finally {
       Type._allowComparisons = false;
     }