Update strong mode expectations to reflect kernel type parameter conventions.

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 18 matching lines @@
   group('front_end_inference_test', () {
     defineReflectiveSuite(() {
       defineReflectiveTests(RunFrontEndInferenceTest);
     });
   }, 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 28 matching lines @@
       if (parts[i] == 'pkg' &&
           parts[i + 1] == 'analyzer' &&
           parts[i + 2] == 'test') {
         return pathos.joinAll(parts.sublist(0, i + 1));
       }
     }
     throw new StateError('Unable to find sdk/pkg/ in $scriptPath');
   }
 }
 
+class _ElementNamer {
+  final ConstructorElement currentFactoryConstructor;
+
+  _ElementNamer(this.currentFactoryConstructor);
+
+  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}::');
+      if (currentFactoryConstructor != null &&
+          identical(enclosing, currentFactoryConstructor.enclosingElement)) {
+        String factoryConstructorName = currentFactoryConstructor.name;
+        if (factoryConstructorName == '') {
+          factoryConstructorName = '•';
+        }
+        buffer.write('$factoryConstructorName::');
+      }
+    }
+    buffer.write('$name');
+  }
+}
+
 class _FrontEndInferenceTest extends BaseAnalysisDriverTest {
   Future<String> runTest(String path, String code) async {
     Uri uri = provider.pathContext.toUri(path);
 
     List<int> lineStarts = new LineInfo.fromContent(code).lineStarts;
     fasta.CompilerContext.current.uriToSource[relativizeUri(uri).toString()] =
         new fasta.Source(lineStarts, UTF8.encode(code));
 
     var validation = new fasta.ValidatingInstrumentation();
     await validation.loadExpectations(uri);
@@ skipping 14 matching lines @@
       }
     } else {
       return null;
     }
   }
 }
 
 /// Instance of [InstrumentationValue] describing a [MethodElement].
 class _InstrumentationValueForMethodElement extends fasta.InstrumentationValue {
   final MethodElement element;
+  final _ElementNamer elementNamer;
 
-  _InstrumentationValueForMethodElement(this.element);
+  _InstrumentationValueForMethodElement(this.element, this.elementNamer);
 
   @override
   String toString() {
     StringBuffer buffer = new StringBuffer();
-    _appendElementName(buffer, element);
+    elementNamer.appendElementName(buffer, element);
     return buffer.toString();
   }
 }
 
 /**
  * Instance of [InstrumentationValue] describing a [DartType].
  */
 class _InstrumentationValueForType extends fasta.InstrumentationValue {
   final DartType type;
+  final _ElementNamer elementNamer;
 
-  _InstrumentationValueForType(this.type);
+  _InstrumentationValueForType(this.type, this.elementNamer);
 
   @override
   String toString() {
     StringBuffer buffer = new StringBuffer();
     _appendType(buffer, type);
     return buffer.toString();
   }
 
   void _appendList<T>(StringBuffer buffer, String open, String close,
       List<T> items, String separator, writeItem(T item),
@@ skipping 22 matching lines @@
   }
 
   void _appendType(StringBuffer buffer, DartType type) {
     if (type is FunctionType) {
       _appendTypeArguments(buffer, type.typeArguments);
       _appendParameters(buffer, type.parameters);
       buffer.write(' -> ');
       _appendType(buffer, type.returnType);
     } else if (type is InterfaceType) {
       ClassElement element = type.element;
-      _appendElementName(buffer, element);
+      elementNamer.appendElementName(buffer, element);
       _appendTypeArguments(buffer, type.typeArguments);
     } else if (type.isBottom) {
       buffer.write('<BottomType>');
+    } else if (type is TypeParameterType) {
+      elementNamer.appendElementName(buffer, type.element);
     } else {
       buffer.write(type.toString());
     }
   }
 
   void _appendTypeArguments(StringBuffer buffer, List<DartType> typeArguments) {
     _appendList<DartType>(buffer, '<', '>', typeArguments, ', ',
         (type) => _appendType(buffer, type));
   }
 }
 
 /**
  * Instance of [InstrumentationValue] describing a list of [DartType]s.
  */
 class _InstrumentationValueForTypeArgs extends fasta.InstrumentationValue {
   final List<DartType> types;
+  final _ElementNamer elementNamer;
 
-  const _InstrumentationValueForTypeArgs(this.types);
+  const _InstrumentationValueForTypeArgs(this.types, this.elementNamer);
 
   @override
   String toString() => types
-      .map((type) => new _InstrumentationValueForType(type).toString())
+      .map((type) =>
+          new _InstrumentationValueForType(type, elementNamer).toString())
       .join(', ');
 }
 
 /**
  * Visitor for ASTs that reports instrumentation for types.
  */
 class _InstrumentationVisitor extends RecursiveAstVisitor<Null> {
   final fasta.Instrumentation _instrumentation;
   final Uri uri;
+  _ElementNamer elementNamer = new _ElementNamer(null);
 
   _InstrumentationVisitor(this._instrumentation, this.uri);
 
   visitBinaryExpression(BinaryExpression node) {
     super.visitBinaryExpression(node);
     _recordMethodTarget(node.operator.charOffset, node.staticElement);
   }
 
+  @override
+  visitConstructorDeclaration(ConstructorDeclaration node) {
+    _ElementNamer oldElementNamer = elementNamer;
+    if (node.factoryKeyword != null) {
+      // Factory constructors are represented in kernel as static methods, so
+      // their type parameters get replicated, e.g.:
+      //     class C<T> {
+      //       factory C.ctor() {
+      //         T t; // Refers to C::T
+      //         ...
+      //       }
+      //     }
+      // gets converted to:
+      //     class C<T> {
+      //       static C<T> C.ctor<T>() {
+      //         T t; // Refers to C::ctor::T
+      //         ...
+      //       }
+      //     }
+      // 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;
+  }
+
   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));
+            new _InstrumentationValueForType(type.returnType, elementNamer));
         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);
           }
         }
       }
     }
   }
@@ skipping 56 matching lines @@
 
   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));
+              new _InstrumentationValueForType(type, elementNamer));
         }
       }
     }
 
     if (element is LocalVariableElement) {
       recordPromotions(element.type);
     } else if (element is ParameterElement) {
       recordPromotions(element.type);
     }
   }
@@ skipping 21 matching lines @@
         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));
+          new _InstrumentationValueForMethodElement(element, elementNamer));
     }
   }
 
   void _recordTopType(int offset, DartType type) {
-    _instrumentation.record(
-        uri, offset, 'topType', new _InstrumentationValueForType(type));
+    _instrumentation.record(uri, offset, 'topType',
+        new _InstrumentationValueForType(type, elementNamer));
   }
 
   void _recordType(int offset, DartType type) {
-    _instrumentation.record(
-        uri, offset, 'type', new _InstrumentationValueForType(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));
+        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);
   }
 }