Set MethodInvocation.interfaceTarget during type inference.

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 12 matching lines @@
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../../dart/analysis/base.dart';
 
 main() {
   // Use a group() wrapper to specify the timeout.
   group('front_end_inference_test', () {
     defineReflectiveSuite(() {
       defineReflectiveTests(RunFrontEndInferenceTest);
     });
-  }, timeout: new Timeout(const Duration(seconds: 60)));
+  }, timeout: new Timeout(const Duration(seconds: 120)));
 }
 
 /// Set this to `true` to cause expectation comments to be updated.
 const bool fixProblems = false;
 
+void _appendElementName(StringBuffer buffer, Element element) {
+  // Synthetic FunctionElement(s) don't have a name or enclosing library.
+  if (element.isSynthetic && element is FunctionElement) {
+    return;
+  }
+
+  LibraryElement library = element.library;
+  if (library == null) {
+    throw new StateError('Unexpected element without library: $element');
+  }
+  String libraryName = library.name;
+
+  String name = element.name ?? '';
+  if (libraryName != 'dart.core' &&
+      libraryName != 'dart.async' &&
+      libraryName != 'test') {
+    buffer.write('$libraryName::');
+  }
+  var enclosing = element.enclosingElement;
+  if (enclosing is ClassElement) {
+    buffer.write('${enclosing.name}::');
+  }
+  buffer.write('$name');
+}
+
 @reflectiveTest
 class RunFrontEndInferenceTest {
   test_run() async {
     String pkgPath = _findPkgRoot();
     String fePath = pathos.join(pkgPath, 'front_end', 'testcases', 'inference');
     List<File> dartFiles = new Directory(fePath)
         .listSync()
         .where((entry) => entry is File && entry.path.endsWith('.dart'))
         .map((entry) => entry as File)
         .toList();
@@ skipping 59 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;
+
+  _InstrumentationValueForMethodElement(this.element);
+
+  @override
+  String toString() {
+    StringBuffer buffer = new StringBuffer();
+    _appendElementName(buffer, element);
+    return buffer.toString();
+  }
+}
+
 /**
  * Instance of [InstrumentationValue] describing a [DartType].
  */
 class _InstrumentationValueForType extends fasta.InstrumentationValue {
   final DartType type;
 
   _InstrumentationValueForType(this.type);
 
   @override
   String toString() {
     StringBuffer buffer = new StringBuffer();
     _appendType(buffer, type);
     return buffer.toString();
   }
 
-  void _appendElementName(StringBuffer buffer, Element element) {
-    // Synthetic FunctionElement(s) don't have a name or enclosing library.
-    if (element.isSynthetic && element is FunctionElement) {
-      return;
-    }
-
-    LibraryElement library = element.library;
-    if (library == null) {
-      throw new StateError('Unexpected element without library: $element');
-    }
-    String libraryName = library.name;
-
-    String name = element.name ?? '';
-    if (libraryName != 'dart.core' &&
-        libraryName != 'dart.async' &&
-        libraryName != 'test') {
-      buffer.write('$libraryName::$name');
-    } else {
-      buffer.write('$name');
-    }
-  }
-
   void _appendList<T>(StringBuffer buffer, String open, String close,
       List<T> items, String separator, writeItem(T item),
       {bool includeEmpty: false}) {
     if (!includeEmpty && items.isEmpty) {
       return;
     }
     buffer.write(open);
     bool first = true;
     for (T item in items) {
       if (!first) {
@@ skipping 52 matching lines @@
 
 /**
  * Visitor for ASTs that reports instrumentation for types.
  */
 class _InstrumentationVisitor extends RecursiveAstVisitor<Null> {
   final fasta.Instrumentation _instrumentation;
   final Uri uri;
 
   _InstrumentationVisitor(this._instrumentation, this.uri);
 
+  visitBinaryExpression(BinaryExpression node) {
+    super.visitBinaryExpression(node);
+    _recordMethodTarget(node.operator.charOffset, node.staticElement);
+  }
+
   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));
         List<FormalParameter> parameters = node.parameters.parameters;
         for (int i = 0; i < parameters.length; i++) {
           FormalParameter parameter = parameters[i];
           if (parameter is SimpleFormalParameter && parameter.type == null) {
             _recordType(parameter.offset, type.parameters[i].type);
           }
         }
       }
     }
   }
 
+  visitIndexExpression(IndexExpression node) {
+    super.visitIndexExpression(node);
+    _recordMethodTarget(node.leftBracket.charOffset, node.staticElement);
+  }
+
   visitInstanceCreationExpression(InstanceCreationExpression node) {
     super.visitInstanceCreationExpression(node);
     DartType type = node.staticType;
     if (type is InterfaceType) {
       if (type.typeParameters.isNotEmpty &&
           node.constructorName.type.typeArguments == null) {
         _recordTypeArguments(node.constructorName.offset, type.typeArguments);
       }
     }
   }
@@ skipping 13 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.typeArguments == null) {
       var inferredTypeArguments = _getInferredFunctionTypeArguments(
               node.function.staticType,
               node.staticInvokeType,
               node.typeArguments)
           .toList();
       if (inferredTypeArguments.isNotEmpty) {
         _recordTypeArguments(node.methodName.offset, inferredTypeArguments);
       }
     }
   }
 
+  visitPrefixExpression(PrefixExpression node) {
+    super.visitPrefixExpression(node);
+    _recordMethodTarget(node.operator.charOffset, node.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',
               const fasta.InstrumentationValueLiteral('none'));
@@ skipping 31 matching lines @@
     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) {
+    if (element is MethodElement) {
+      _instrumentation.record(uri, offset, 'target',
+          new _InstrumentationValueForMethodElement(element));
+    }
+  }
+
   void _recordTopType(int offset, DartType type) {
     _instrumentation.record(
         uri, offset, 'topType', new _InstrumentationValueForType(type));
   }
 
   void _recordType(int offset, DartType type) {
     _instrumentation.record(
         uri, offset, 'type', new _InstrumentationValueForType(type));
   }
 
   void _recordTypeArguments(int offset, List<DartType> typeArguments) {
     _instrumentation.record(uri, offset, 'typeArgs',
         new _InstrumentationValueForTypeArgs(typeArguments));
   }
 
   /// 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);
   }
 }