Rework linker type inference using ExprBuilder.

This CL changes the way linker type inference works.  Instead of
walking the operations in an UnlinkedExpr in order and inferring types
directly, it first builds an AST for the expression using ExprBuilder,
then uses ResolverVisitor to resolve the AST and perform type
inference.

This helps ensure that summary type inference and ordinary AST-based
type inference produce the same result, since they now use the same
core algorithm.  In particular, this means that summary type inference
now does downwards inference properly.

Since the ResolverVisitor makes greater use of the element model than
the rest of the linker, this required implementing additional methods
in the linker's element model.

This CL includes some minor fixes to ExprBuilder that were uncovered
during testing.  It also contains some minor changes to
ResolverVisitor to make it work during linking.

Fixes #32525.
Fixes #32394.

Change-Id: I5ec9b2bf5565ad30b8cc856475334323dc118da8
Reviewed-on: https://dart-review.googlesource.com/48741
Commit-Queue: Paul Berry <paulberry@google.com>
Reviewed-by: Konstantin Shcheglov <scheglov@google.com>

Author: stereotype441

pkg/analysis_server/test/services/correction/fix_test.dart

@@ -7043,15 +7043,16 @@ set speed2(int ms) {}
   }
 
   test_removeTypeAnnotation_avoidTypesOnClosureParameters_FunctionTypedFormalParameter() async {
+    // Note: explicit type `Function` to work around dartbug.com/32708.
     String src = '''
-var functionWithFunction = (/*LINT*/int f(int x)) => f(0);
+Function functionWithFunction = (/*LINT*/int f(int x)) => f(0);
 ''';
     await findLint(src, LintNames.avoid_types_on_closure_parameters);
 
     await applyFix(DartFixKind.REPLACE_WITH_IDENTIFIER);
 
     verifyResult('''
-var functionWithFunction = (f) => f(0);
+Function functionWithFunction = (f) => f(0);
 ''');
   }
 

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

@@ -4999,7 +4999,8 @@ class ResolverVisitor extends ScopedVisitor {
     }
     this.inferenceContext = new InferenceContext._(
         typeProvider, typeSystem, strongModeHints, errorReporter);
-    this.typeAnalyzer = new StaticTypeAnalyzer(this);
+    this.typeAnalyzer =
+        new StaticTypeAnalyzer(this, propagateTypes: propagateTypes);
   }
 
   /**
@@ -5723,7 +5724,8 @@ class ResolverVisitor extends ScopedVisitor {
     }
     // Clone the ASTs for default formal parameters, so that we can use them
     // during constant evaluation.
-    if (!_hasSerializedConstantInitializer(element)) {
+    if (element is ConstVariableElement &&
+        !_hasSerializedConstantInitializer(element)) {
       (element as ConstVariableElement).constantInitializer =
           _createCloner().cloneNode(node.defaultValue);
     }

pkg/analyzer/lib/src/summary/expr_builder.dart

@@ -432,7 +432,6 @@ class ExprBuilder {
     simpleParam.identifier.staticElement = param;
     simpleParam.element = param;
     var unlinkedParam = param.unlinkedParam;
-    FormalParameter paramAst;
     if (unlinkedParam.kind == UnlinkedParamKind.positional) {
       return AstTestFactory.positionalFormalParameter(simpleParam, null);
     } else if (unlinkedParam.kind == UnlinkedParamKind.named) {
@@ -570,13 +569,17 @@ class ExprBuilder {
     ReferenceInfo info = resynthesizer.getReferenceInfo(ref.reference);
     Expression node = _buildIdentifierSequence(info);
     TypeArgumentList typeArguments = _buildTypeArguments();
+    var period = TokenFactory.tokenFromType(TokenType.PERIOD);
+    var argumentList = AstTestFactory.argumentList(arguments);
     if (node is SimpleIdentifier) {
       _push(astFactory.methodInvocation(
-          null,
-          TokenFactory.tokenFromType(TokenType.PERIOD),
-          node,
-          typeArguments,
-          AstTestFactory.argumentList(arguments)));
+          null, period, node, typeArguments, argumentList));
+    } else if (node is PropertyAccess) {
+      _push(astFactory.methodInvocation(
+          node.target, period, node.propertyName, typeArguments, argumentList));
+    } else if (node is PrefixedIdentifier) {
+      _push(astFactory.methodInvocation(
+          node.prefix, period, node.identifier, typeArguments, argumentList));
     } else {
       throw new UnimplementedError('For ${node?.runtimeType}: $node');
     }