Create an abstract layer to customize querying element types.

This will be needed for the NNBD migration engine.

Currently only used in checker.dart.  Later CLs will convert the
resolver to use this abstraction layer as well.

The runtime overhead of this abstraction should be negligible, since
under normal analyzer operation, there will only be a single const
instance of this class, and no instances of any subclasses.  So the VM
should be able to trivially inline all uses of the abstraction layer.

Change-Id: I0132b76238606e6e6b789169a62806d09f10f71d
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/127490
Commit-Queue: Paul Berry <paulberry@google.com>
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>

Author: stereotype441

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

@@ -0,0 +1,38 @@
+// Copyright (c) 2019, 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/element.dart';
+import 'package:analyzer/dart/element/type.dart';
+
+/// Abstraction layer allowing the mechanism for looking up the types of
+/// elements to be customized.
+///
+/// This is needed for the NNBD migration engine, which needs to analyze
+/// NNBD-disabled code as though it has NNBD enabled.
+///
+/// This base class implementation gets types directly from the elements; for
+/// other behaviors, create a class that extends or implements this class.
+class ElementTypeProvider {
+  const ElementTypeProvider();
+
+  /// Queries the parameters of an executable element's signature.
+  ///
+  /// Equivalent to `getExecutableType(...).parameters`.
+  List<ParameterElement> getExecutableParameters(ExecutableElement element) =>
+      element.parameters;
+
+  /// Queries the return type of an executable element.
+  ///
+  /// Equivalent to `getExecutableType(...).returnType`.
+  DartType getExecutableReturnType(FunctionTypedElement element) =>
+      element.returnType;
+
+  /// Queries the full type of an executable element.
+  ///
+  /// Guaranteed to be a function type.
+  FunctionType getExecutableType(FunctionTypedElement element) => element.type;
+
+  /// Queries the type of a variable element.
+  DartType getVariableType(VariableElement variable) => variable.type;
+}

pkg/analyzer/lib/src/task/strong/checker.dart

@@ -25,6 +25,7 @@ import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type_algebra.dart';
 import 'package:analyzer/src/dart/resolver/variance.dart';
 import 'package:analyzer/src/error/codes.dart' show StrongModeCode;
+import 'package:analyzer/src/generated/element_type_provider.dart';
 import 'package:analyzer/src/generated/engine.dart' show AnalysisOptionsImpl;
 import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/generated/type_system.dart';
@@ -36,20 +37,25 @@ import 'ast_properties.dart';
 /// gets the known static type of the expression.
 DartType getExpressionType(
     Expression expression, TypeSystemImpl typeSystem, TypeProvider typeProvider,
-    {bool read = false}) {
+    {bool read = false,
+    ElementTypeProvider elementTypeProvider = const ElementTypeProvider()}) {
   DartType type;
   if (read) {
-    type = getReadType(expression);
+    type = getReadType(expression, elementTypeProvider: elementTypeProvider);
   } else {
     type = expression.staticType;
   }
   type ??= DynamicTypeImpl.instance;
   return type;
 }
 
-DartType getReadType(Expression expression) {
+DartType getReadType(Expression expression,
+    {ElementTypeProvider elementTypeProvider = const ElementTypeProvider()}) {
   if (expression is IndexExpression) {
-    return expression.auxiliaryElements?.staticElement?.returnType;
+    var staticElement = expression.auxiliaryElements?.staticElement;
+    return staticElement == null
+        ? null
+        : elementTypeProvider.getExecutableReturnType(staticElement);
   }
   {
     Element setter;
@@ -63,14 +69,17 @@ DartType getReadType(Expression expression) {
     if (setter is PropertyAccessorElement && setter.isSetter) {
       var getter = setter.variable.getter;
       if (getter != null) {
-        return getter.returnType;
+        return elementTypeProvider.getExecutableReturnType(getter);
       }
     }
   }
   if (expression is SimpleIdentifier) {
     var aux = expression.auxiliaryElements;
     if (aux != null) {
-      return aux.staticElement?.returnType;
+      var staticElement = aux.staticElement;
+      return staticElement == null
+          ? null
+          : elementTypeProvider.getExecutableReturnType(staticElement);
     }
   }
   return expression.staticType;