Implement type inference for null-aware property gets.

pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart

 // Copyright (c) 2017, 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:front_end/src/base/instrumentation.dart';
 import 'package:front_end/src/fasta/errors.dart' show internalError;
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart';
 import 'package:front_end/src/fasta/names.dart' show callName;
 import 'package:front_end/src/fasta/type_inference/type_inference_engine.dart';
 import 'package:front_end/src/fasta/type_inference/type_inference_listener.dart';
@@ skipping 609 matching lines @@
     return inferredType;
   }
 
   @override
   void inferParameterInitializer(
       Expression initializer, DartType declaredType) {
     assert(closureContext == null);
     inferExpression(initializer, declaredType, false);
   }
 
+  /// Performs the core type inference algorithm for property gets (this handles
+  /// both null-aware and non-null-aware property gets).
+  DartType inferPropertyGet(
+      Expression expression,
+      Expression receiver,
+      int fileOffset,
+      PropertyGet desugaredGet,
+      DartType typeContext,
+      bool typeNeeded) {
+    typeNeeded =
+        listener.propertyGetEnter(expression, typeContext) || typeNeeded;
+    // First infer the receiver so we can look up the getter that was invoked.
+    var receiverType = inferExpression(receiver, null, true);
+    Member interfaceMember =
+        findInterfaceMember(receiverType, desugaredGet.name, fileOffset);
+    if (isTopLevel &&
+        ((interfaceMember is Procedure &&
+                interfaceMember.kind == ProcedureKind.Getter) ||
+            interfaceMember is Field)) {
+      if (TypeInferenceEngineImpl.fullTopLevelInference) {
+        if (interfaceMember is KernelField) {
+          var fieldNode = KernelMember.getFieldNode(interfaceMember);
+          if (fieldNode != null) {
+            engine.inferFieldFused(fieldNode, this.fieldNode);
+          }
+        }
+      } else {
+        // References to fields and getters can't be relied upon for top level
+        // inference.
+        recordNotImmediatelyEvident(fileOffset);
+      }
+    }
+    desugaredGet.interfaceTarget = interfaceMember;
+    var inferredType =
+        getCalleeType(interfaceMember, receiverType, desugaredGet.name);
+    // TODO(paulberry): Infer tear-off type arguments if appropriate.
+    listener.propertyGetExit(expression, inferredType);
+    return typeNeeded ? inferredType : null;
+  }
+
   /// Modifies a type as appropriate when inferring a closure return type.
   DartType inferReturnType(DartType returnType, bool isExpressionFunction) {
     if (returnType == null) {
       // Analyzer infers `Null` if there is no `return` expression; the spec
       // says to return `void`.  TODO(paulberry): resolve this difference.
       return coreTypes.nullClass.rawType;
     }
     if (isExpressionFunction &&
         returnType is InterfaceType &&
         identical(returnType.classNode, coreTypes.nullClass)) {
@@ skipping 60 matching lines @@
   void _forEachArgument(
       Arguments arguments, void callback(String name, Expression expression)) {
     for (var expression in arguments.positional) {
       callback(null, expression);
     }
     for (var namedExpression in arguments.named) {
       callback(namedExpression.name, namedExpression.value);
     }
   }
 }