Generated front_end/testcases/inference test files from Analyzer tests.

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 40 matching lines @@
       .where((entry) => entry is File && entry.path.endsWith('.dart'))
       .map((entry) => entry as File)
       .toList();
 
   for (File file in dartFiles) {
     var test = new _FrontEndInferenceTest();
     await test.setUp();
     try {
       String code = file.readAsStringSync();
       await test.runTest(file.path, code);
-    } catch (_) {
+    } catch (_, st) {
       print(_);
+      print(st);
     } finally {
       await test.tearDown();
     }
   }
 }
 
 class _FrontEndInferenceTest extends BaseAnalysisDriverTest {
   Future<Null> runTest(String path, String code) async {
+//    if (!path

[Paul Berry, 2017/04/27 21:19:29]

Was this left in by accident?

+//        .endsWith('downwards_inference_on_generic_function_expressions.dart')) {
+//      return;
+//    }
     Uri uri = provider.pathContext.toUri(path);
 
     List<int> lineStarts = new LineInfo.fromContent(code).lineStarts;
     fasta.CompilerContext.current.uriToSource[uri.toString()] =
         new fasta.Source(lineStarts, UTF8.encode(code));
 
     var validation = new fasta.ValidatingInstrumentation();
     await validation.loadExpectations(uri);
 
     provider.newFile(path, code);
@@ skipping 19 matching lines @@
 
   @override
   String toString() {
     StringBuffer buffer = new StringBuffer();
     _appendType(buffer, type);
     return buffer.toString();
   }
 
   void _appendElementName(StringBuffer buffer, Element element) {
     String name = element.name;
+    if (element.library == null) {
+      // TODO(scheglov) This is wrong - every element must be in a library.
+      buffer.write('<unknown>::$name');
+      return;
+    }
     String libraryName = element.library.name;
     if (libraryName == '') {
       throw new StateError('The element $name must be in a named library.');
     }
     if (libraryName != 'dart.core' &&
         libraryName != 'dart.async' &&
         libraryName != 'test') {
       buffer.write('$libraryName::$name');
     } else {
       buffer.write('$name');
@@ skipping 15 matching lines @@
       writeItem(item);
       first = false;
     }
     buffer.write(close);
   }
 
   void _appendParameters(
       StringBuffer buffer, List<ParameterElement> parameters) {
     _appendList<ParameterElement>(buffer, '(', ')', parameters, ', ',
         (parameter) {
-      _appendType(buffer, type);
+      _appendType(buffer, parameter.type);
       buffer.write(' ');
       buffer.write(parameter.name);
     }, includeEmpty: true);
   }
 
   void _appendType(StringBuffer buffer, DartType type) {
     if (type is FunctionType) {
       Element element = type.element;
       _appendElementName(buffer, element);
       _appendTypeArguments(buffer, type.typeArguments);
@@ skipping 60 matching lines @@
     super.visitInstanceCreationExpression(node);
     DartType type = node.staticType;
     if (type is InterfaceType) {
       if (type.typeParameters.isNotEmpty &&
           node.constructorName.type.typeArguments == null) {
         _recordTypeArguments(node.offset, type.typeArguments);
       }
     }
   }
 
+  visitListLiteral(ListLiteral node) {
+    super.visitListLiteral(node);
+    if (node.typeArguments == null) {
+      DartType type = node.staticType;
+      if (type is InterfaceType) {
+        _recordTypeArguments(node.offset, type.typeArguments);
+      }
+    }
+  }
+
+  visitMapLiteral(MapLiteral node) {
+    super.visitMapLiteral(node);
+    if (node.typeArguments == null) {
+      DartType type = node.staticType;
+      if (type is InterfaceType) {
+        _recordTypeArguments(node.offset, type.typeArguments);
+      }
+    }
+  }
+
   visitSimpleIdentifier(SimpleIdentifier node) {
     super.visitSimpleIdentifier(node);
     Element element = node.staticElement;
     if (element is LocalVariableElement && node.inGetterContext()) {
       int offset = node.offset;
       DartType type = node.staticType;
       if (identical(type, element.type)) {
         _instrumentation.record(uri, offset, 'promotedType',
             const fasta.InstrumentationValueLiteral('none'));
       } else {
@@ skipping 25 matching lines @@
   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));
   }
 }