Implement type inference for PropertyGet.

pkg/analyzer/test/src/task/strong/front_end_inference_test.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 file.
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
@@ skipping 136 matching lines @@
         return null;
       } else {
         return validation.problemsAsString;
       }
     } else {
       return null;
     }
   }
 }
 
-/// Instance of [InstrumentationValue] describing a [MethodElement].
-class _InstrumentationValueForMethodElement extends fasta.InstrumentationValue {
-  final MethodElement element;
+/// Instance of [InstrumentationValue] describing an [ExecutableElement].
+class _InstrumentationValueForExecutableElement
+    extends fasta.InstrumentationValue {
+  final ExecutableElement element;
   final _ElementNamer elementNamer;
 
-  _InstrumentationValueForMethodElement(this.element, this.elementNamer);
+  _InstrumentationValueForExecutableElement(this.element, this.elementNamer);
 
   @override
   String toString() {
     StringBuffer buffer = new StringBuffer();
     elementNamer.appendElementName(buffer, element);
     return buffer.toString();
   }
 }
 
 /**
@@ skipping 114 matching lines @@
       //       }
       //     }
       // So to match kernel behavior, we have to arrange for this renaming to
       // happen during output.
       elementNamer = new _ElementNamer(node.element);
     }
     super.visitConstructorDeclaration(node);
     elementNamer = oldElementNamer;
   }
 
+  @override
+  visitDeclaredIdentifier(DeclaredIdentifier node) {
+    super.visitDeclaredIdentifier(node);
+    if (node.type == null) {
+      _recordType(node.identifier.offset, node.element.type);
+    }
+  }
+
   visitFunctionExpression(FunctionExpression node) {
     super.visitFunctionExpression(node);
     if (node.parent is! FunctionDeclaration) {
       DartType type = node.staticType;
       if (type is FunctionType) {
         _instrumentation.record(uri, node.offset, 'returnType',
             new _InstrumentationValueForType(type.returnType, elementNamer));
         List<FormalParameter> parameters = node.parameters.parameters;
         for (int i = 0; i < parameters.length; i++) {
           FormalParameter parameter = parameters[i];
@@ skipping 51 matching lines @@
     if (node.typeArguments == null) {
       DartType type = node.staticType;
       if (type is InterfaceType) {
         _recordTypeArguments(node.offset, type.typeArguments);
       }
     }
   }
 
   visitMethodInvocation(MethodInvocation node) {
     super.visitMethodInvocation(node);
-    _recordMethodTarget(node.methodName.offset, node.methodName.staticElement);
+    if (node.target != null) {
+      _recordMethodTarget(
+          node.methodName.offset, node.methodName.staticElement);
+    }
     if (node.typeArguments == null) {
       var inferredTypeArguments = _getInferredFunctionTypeArguments(
               node.function.staticType,
               node.staticInvokeType,
               node.typeArguments)
           .toList();
       if (inferredTypeArguments.isNotEmpty) {
         _recordTypeArguments(node.methodName.offset, inferredTypeArguments);
       }
     }
   }
 
+  @override
+  visitPrefixedIdentifier(PrefixedIdentifier node) {
+    super.visitPrefixedIdentifier(node);
+    if (node.prefix.staticElement is! PrefixElement &&
+        node.prefix.staticElement is! ClassElement) {
+      if (node.identifier.inGetterContext()) {
+        _recordMethodTarget(
+            node.identifier.offset, node.identifier.staticElement);
+      }
+    }
+  }
+
   visitPrefixExpression(PrefixExpression node) {
     super.visitPrefixExpression(node);
     _recordMethodTarget(node.operator.charOffset, node.staticElement);
   }
 
+  @override
+  visitPropertyAccess(PropertyAccess node) {
+    super.visitPropertyAccess(node);
+    if (node.propertyName.inGetterContext()) {
+      _recordMethodTarget(
+          node.propertyName.offset, node.propertyName.staticElement);
+    }
+  }
+
   visitSimpleIdentifier(SimpleIdentifier node) {
     super.visitSimpleIdentifier(node);
     Element element = node.staticElement;
     void recordPromotions(DartType elementType) {
       if (node.inGetterContext() && !node.inDeclarationContext()) {
         int offset = node.offset;
         DartType type = node.staticType;
         if (!identical(type, elementType)) {
           _instrumentation.record(uri, offset, 'promotedType',
               new _InstrumentationValueForType(type, elementNamer));
         }
       }
     }
 
     if (element is LocalVariableElement) {
       recordPromotions(element.type);
     } else if (element is ParameterElement) {
       recordPromotions(element.type);
     }
   }
 
-  @override
-  visitDeclaredIdentifier(DeclaredIdentifier node) {
-    super.visitDeclaredIdentifier(node);
-    if (node.type == null) {
-      _recordType(node.identifier.offset, node.element.type);
-    }
-  }
-
   visitVariableDeclarationList(VariableDeclarationList node) {
     super.visitVariableDeclarationList(node);
     if (node.type == null) {
       for (VariableDeclaration variable in node.variables) {
         VariableElement element = variable.element;
         if (element is LocalVariableElement) {
           _recordType(variable.name.offset, element.type);
         } else {
           _recordTopType(variable.name.offset, element.type);
         }
       }
     }
   }
 
   /// Based on DDC code generator's `_emitFunctionTypeArguments`
   Iterable<DartType> _getInferredFunctionTypeArguments(
       DartType g, DartType f, TypeArgumentList typeArgs) {
     if (g is FunctionType &&
         g.typeFormals.isNotEmpty &&
         f is FunctionType &&
         f.typeFormals.isEmpty) {
       return _recoverTypeArguments(g, f);
     } else {
       return const [];
     }
   }
 
   void _recordMethodTarget(int offset, Element element) {

[scheglov, 2017/05/31 18:40:13]

Maybe this method should also be renamed.

[Paul Berry, 2017/05/31 19:08:33]

Good point.  Renamed to "_recordTarget".

-    if (element is MethodElement) {
+    if (element is ExecutableElement) {
       _instrumentation.record(uri, offset, 'target',
-          new _InstrumentationValueForMethodElement(element, elementNamer));
+          new _InstrumentationValueForExecutableElement(element, elementNamer));
     }
   }
 
   void _recordTopType(int offset, DartType type) {
     _instrumentation.record(uri, offset, 'topType',
         new _InstrumentationValueForType(type, elementNamer));
   }
 
   void _recordType(int offset, DartType type) {
     _instrumentation.record(uri, offset, 'type',
         new _InstrumentationValueForType(type, elementNamer));
   }
 
   void _recordTypeArguments(int offset, List<DartType> typeArguments) {
     _instrumentation.record(uri, offset, 'typeArgs',
         new _InstrumentationValueForTypeArgs(typeArguments, elementNamer));
   }
 
   /// Based on DDC code generator's `_recoverTypeArguments`
   Iterable<DartType> _recoverTypeArguments(FunctionType g, FunctionType f) {
     assert(identical(g.element, f.element));
     assert(g.typeFormals.isNotEmpty && f.typeFormals.isEmpty);
     assert(g.typeFormals.length + g.typeArguments.length ==
         f.typeArguments.length);
     return f.typeArguments.skip(g.typeArguments.length);
   }
 }