Resynthesize InterfaceType, class type parameters and supertype.

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/element/type.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/src/dart/element/element.dart';
+import 'package:analyzer/src/dart/element/type.dart';
+import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/summary/resynthesize.dart';
 import 'package:front_end/file_system.dart';
 import 'package:front_end/src/base/performace_logger.dart';
 import 'package:front_end/src/fasta/uri_translator_impl.dart';
 import 'package:front_end/src/incremental/byte_store.dart';
 import 'package:front_end/src/incremental/kernel_driver.dart';
 import 'package:kernel/kernel.dart' as kernel;
 import 'package:kernel/target/targets.dart';
 import 'package:path/path.dart' as pathos;
-import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../context/mock_sdk.dart';
 import 'resynthesize_common.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(ResynthesizeKernelStrongTest);
   });
 }
@@ skipping 44 matching lines @@
     KernelResult kernelResult = await driver.getKernel(testUri);
 
     var libraryMap = <String, kernel.Library>{};
     for (var cycleResult in kernelResult.results) {
       for (var library in cycleResult.kernelLibraries) {
         String uriStr = library.importUri.toString();
         libraryMap[uriStr] = library;
       }
     }
 
-    kernel.Library kernelLibrary = libraryMap[testUriStr];
-    expect(kernelLibrary, isNotNull);
-
-    return new LibraryElementImpl.forKernel(context,
-        new _KernelLibraryResynthesizerContextImpl(libraryMap, kernelLibrary));
+    var resynthesizer = new _KernelResynthesizer(context, libraryMap);
+    return resynthesizer.getLibrary(testUriStr);
   }
 
   @override
   SummaryResynthesizer encodeDecodeLibrarySource(Source librarySource) {
     // TODO(scheglov): implement encodeDecodeLibrarySource
     throw new UnimplementedError();
   }
 
   @failingTest
   test_class_alias() async {
@@ skipping 26 matching lines @@
     await super
         .test_class_alias_with_forwarding_constructors_type_substitution_complex();
   }
 
   @failingTest
   test_class_alias_with_mixin_members() async {
     await super.test_class_alias_with_mixin_members();
   }
 
   @failingTest
-  test_class_constructor_explicit_type_params() async {
-    await super.test_class_constructor_explicit_type_params();
-  }
-
-  @failingTest
   test_class_constructor_factory() async {
     await super.test_class_constructor_factory();
   }
 
   @failingTest
   test_class_constructor_field_formal_dynamic_dynamic() async {
     await super.test_class_constructor_field_formal_dynamic_dynamic();
   }
 
   @failingTest
@@ skipping 60 matching lines @@
   test_class_constructor_fieldFormal_optional_noDefault() async {
     await super.test_class_constructor_fieldFormal_optional_noDefault();
   }
 
   @failingTest
   test_class_constructor_fieldFormal_optional_withDefault() async {
     await super.test_class_constructor_fieldFormal_optional_withDefault();
   }
 
   @failingTest
-  test_class_constructor_implicit_type_params() async {
-    await super.test_class_constructor_implicit_type_params();
-  }
-
-  @failingTest
   test_class_constructor_params() async {
     await super.test_class_constructor_params();
   }
 
   @failingTest
   test_class_documented() async {
     await super.test_class_documented();
   }
 
   @failingTest
@@ skipping 140 matching lines @@
   test_class_setter_static() async {
     await super.test_class_setter_static();
   }
 
   @failingTest
   test_class_setters() async {
     await super.test_class_setters();
   }
 
   @failingTest
-  test_class_supertype() async {
-    await super.test_class_supertype();
-  }
-
-  @failingTest
-  test_class_type_parameters() async {
-    await super.test_class_type_parameters();
-  }
-
-  @failingTest
   test_class_type_parameters_bound() async {
     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
@@ skipping 2252 matching lines @@
   }
 
   @override
   Future<String> readAsString() async {
     return file.readAsStringSync();
   }
 }
 
 class _KernelLibraryResynthesizerContextImpl
     implements KernelLibraryResynthesizerContext {
-  /// TODO(scheglov) we don't use this yet, make it private later
-  final Map<String, kernel.Library> libraryMap;
+  final _KernelResynthesizer _resynthesizer;
 
   @override
   final kernel.Library library;
 
-  _KernelLibraryResynthesizerContextImpl(this.libraryMap, this.library);
+  _KernelLibraryResynthesizerContextImpl(this._resynthesizer, this.library);
+
+  @override
+  InterfaceType getInterfaceType(
+      ElementImpl context, kernel.Supertype kernelType) {
+    return _getInterfaceType(
+        kernelType.className.canonicalName, kernelType.typeArguments);
+  }
+
+  DartType getType(ElementImpl context, kernel.DartType kernelType) {
+    if (kernelType is kernel.InterfaceType) {
+      return _getInterfaceType(
+          kernelType.className.canonicalName, kernelType.typeArguments);
+    }
+    // TODO(scheglov) Support other kernel types.
+    return null;
+  }
+
+  InterfaceType _getInterfaceType(
+      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))
+          .toList(growable: false);
+      return arguments;
+    });
+  }
 }
+
+class _KernelResynthesizer {
+  final AnalysisContext _analysisContext;
+  final Map<String, kernel.Library> _kernelMap;
+  final Map<String, LibraryElementImpl> _libraryMap = {};
+
+  _KernelResynthesizer(this._analysisContext, this._kernelMap);
+
+  LibraryElementImpl getLibrary(String uriStr) {
+    return _libraryMap.putIfAbsent(uriStr, () {
+      var kernel = _kernelMap[uriStr];
+      if (kernel == null) return null;
+      var libraryContext =
+          new _KernelLibraryResynthesizerContextImpl(this, kernel);
+      return new LibraryElementImpl.forKernel(_analysisContext, libraryContext);
+    });
+  }
+}