Start marking @_fastaProblem, fix for unresolved mixin, fix for type parameter context.

pkg/analyzer/test/src/summary/resynthesize_kernel_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.
 
 library analyzer.test.src.summary.resynthesize_kernel_test;
 
 import 'dart:async';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
@@ skipping 22 matching lines @@
 
 import '../context/mock_sdk.dart';
 import 'resynthesize_common.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(ResynthesizeKernelStrongTest);
   });
 }
 
+/// Tests marked with this annotation fail because of a Fasta problem.
+const _fastaProblem = const Object();
+
 @reflectiveTest
 class ResynthesizeKernelStrongTest extends ResynthesizeTest {
   final resourceProvider = new MemoryResourceProvider(context: pathos.posix);
 
   @override
   bool get isSharedFrontEnd => true;
 
   @override
   bool get isStrongMode => true;
 
@@ skipping 54 matching lines @@
     // TODO(scheglov): implement encodeDecodeLibrarySource
     throw new UnimplementedError();
   }
 
   @failingTest
   test_class_alias_documented() async {
     await super.test_class_alias_documented();
   }
 
   @failingTest
-  test_class_alias_with_forwarding_constructors_type_substitution() async {
-    await super
-        .test_class_alias_with_forwarding_constructors_type_substitution();
-  }
-
-  @failingTest
-  test_class_alias_with_forwarding_constructors_type_substitution_complex() async {
-    await super
-        .test_class_alias_with_forwarding_constructors_type_substitution_complex();
-  }
-
-  @failingTest
+  @_fastaProblem
   test_class_constructor_field_formal_multiple_matching_fields() async {
     // Fasta does not generate the class.
     // main() with a fatal error is generated instead.
     await super.test_class_constructor_field_formal_multiple_matching_fields();
   }
 
   @failingTest
   test_class_documented_tripleSlash() async {
     await super.test_class_documented_tripleSlash();
   }
 
   @failingTest
   test_class_documented_withLeadingNotDocumentation() async {
     await super.test_class_documented_withLeadingNotDocumentation();
   }
 
   @failingTest
+  @_fastaProblem
   test_class_interfaces_unresolved() async {
+    // Fasta generates additional `#errors` top-level variable.
     await super.test_class_interfaces_unresolved();
   }
 
   @failingTest
+  @_fastaProblem
   test_class_mixins_unresolved() async {
+    // Fasta generates additional `#errors` top-level variable.
     await super.test_class_mixins_unresolved();
   }
 
   @failingTest
+  @_fastaProblem
   test_class_supertype_unresolved() async {
+    // Fasta generates additional `#errors` top-level variable.
     await super.test_class_supertype_unresolved();
   }
 
   @failingTest
+  @_fastaProblem
   test_class_type_parameters_bound() async {
+    // Fasta does not provide a flag for explicit vs. implicit Object bound.
     await super.test_class_type_parameters_bound();
   }
 
   @failingTest
-  test_class_type_parameters_f_bound_complex() async {
-    await super.test_class_type_parameters_f_bound_complex();
-  }
-
-  @failingTest
   test_closure_generic() async {
     await super.test_closure_generic();
   }
 
   @failingTest
   test_closure_in_variable_declaration_in_part() async {
     await super.test_closure_in_variable_declaration_in_part();
   }
 
   @failingTest
@@ skipping 774 matching lines @@
     await super
         .test_inferred_function_type_in_generic_class_in_generic_method();
   }
 
   @failingTest
   test_inferred_type_is_typedef() async {
     await super.test_inferred_type_is_typedef();
   }
 
   @failingTest
-  test_inferred_type_refers_to_bound_type_param() async {
-    await super.test_inferred_type_refers_to_bound_type_param();
-  }
-
-  @failingTest
   test_inferred_type_refers_to_function_typed_param_of_typedef() async {
     await super.test_inferred_type_refers_to_function_typed_param_of_typedef();
   }
 
   @failingTest
   test_inferred_type_refers_to_function_typed_parameter_type_generic_class() async {
     await super
         .test_inferred_type_refers_to_function_typed_parameter_type_generic_class();
   }
 
@@ skipping 1131 matching lines @@
 
   @override
   Expression getExpression(kernel.Expression expression) {
     return new _ExprBuilder(this).build(expression);
   }
 
   @override
   InterfaceType getInterfaceType(
       ElementImpl context, kernel.Supertype kernelType) {
     return _getInterfaceType(
-        kernelType.className.canonicalName, kernelType.typeArguments);
+        context, kernelType.className.canonicalName, kernelType.typeArguments);
   }
 
   @override
   LibraryElement getLibrary(String uriStr) {
     return _resynthesizer.getLibrary(uriStr);
   }
 
   DartType getType(ElementImpl context, kernel.DartType kernelType) {
     if (kernelType is kernel.DynamicType) return DynamicTypeImpl.instance;
     if (kernelType is kernel.VoidType) return VoidTypeImpl.instance;
     if (kernelType is kernel.InterfaceType) {
-      return _getInterfaceType(
-          kernelType.className.canonicalName, kernelType.typeArguments);
+      return _getInterfaceType(context, kernelType.className.canonicalName,
+          kernelType.typeArguments);
     }
     if (kernelType is kernel.TypeParameterType) {
       kernel.TypeParameter kTypeParameter = kernelType.parameter;
       return _getTypeParameter(context, kTypeParameter).type;
     }
     // TODO(scheglov) Support other kernel types.
     throw new UnimplementedError('For ${kernelType.runtimeType}');
   }
 
   /**
@@ skipping 62 matching lines @@
         return parentElement.getNamedConstructor(name.name) as ElementImpl;
       } else if (isMethod) {
         return parentElement.getMethod(name.name) as ElementImpl;
       }
       return null;
     }
 
     throw new UnimplementedError('Should not be reached.');
   }
 
-  InterfaceType _getInterfaceType(
+  InterfaceType _getInterfaceType(ElementImpl context,
       kernel.CanonicalName className, List<kernel.DartType> kernelArguments) {
     var libraryName = className.parent;
     var libraryElement = _resynthesizer.getLibrary(libraryName.name);
     ClassElementImpl classElement = libraryElement.getType(className.name);
 
     if (kernelArguments.isEmpty) {
       return classElement.type;
     }
 
     return new InterfaceTypeImpl.elementWithNameAndArgs(
         classElement, classElement.name, () {
       List<DartType> arguments = kernelArguments
-          .map((kernel.DartType k) => getType(classElement, k))
+          .map((kernel.DartType k) => getType(context, k))
           .toList(growable: false);
       return arguments;
     });
   }
 
   /// Return the [TypeParameterElement] for the given [kernelTypeParameter].
   TypeParameterElement _getTypeParameter(
       ElementImpl context, kernel.TypeParameter kernelTypeParameter) {
     String name = kernelTypeParameter.name;
     for (var ctx = context; ctx != null; ctx = ctx.enclosingElement) {
@@ skipping 41 matching lines @@
   }
 
   /**
    * Get the [Source] object for the given [uri].
    */
   Source _getSource(String uri) {
     return _sources.putIfAbsent(
         uri, () => _analysisContext.sourceFactory.forUri(uri));
   }
 }