Resynthesize instance creation expressions from Kernel.

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';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 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/generated/testing/ast_test_factory.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:kernel/type_environment.dart' as kernel;
 import 'package:package_config/packages.dart';
 import 'package:path/path.dart' as pathos;
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../context/mock_sdk.dart';
 import 'resynthesize_common.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(ResynthesizeKernelStrongTest);
@@ skipping 50 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;
       }
     }
 
-    var resynthesizer = new _KernelResynthesizer(context, libraryMap);
+    var resynthesizer =
+        new _KernelResynthesizer(context, kernelResult.types, libraryMap);
     return resynthesizer.getLibrary(testUriStr);
   }
 
   @override
   SummaryResynthesizer encodeDecodeLibrarySource(Source librarySource) {
     // TODO(scheglov): implement encodeDecodeLibrarySource
     throw new UnimplementedError();
   }
 
   @failingTest
@@ skipping 74 matching lines @@
   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
-  test_class_type_parameters_f_bound_simple() async {
-    await super.test_class_type_parameters_f_bound_simple();
-  }
-
-  @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 10 matching lines @@
   test_const_invalid_intLiteral() async {
     await super.test_const_invalid_intLiteral();
   }
 
   @failingTest
   test_const_invalid_topLevel() async {
     await super.test_const_invalid_topLevel();
   }
 
   @failingTest
-  test_const_invokeConstructor_generic_named() async {
-    await super.test_const_invokeConstructor_generic_named();
-  }
-
-  @failingTest
   test_const_invokeConstructor_generic_named_imported() async {
     await super.test_const_invokeConstructor_generic_named_imported();
   }
 
   @failingTest
   test_const_invokeConstructor_generic_named_imported_withPrefix() async {
     await super
         .test_const_invokeConstructor_generic_named_imported_withPrefix();
   }
 
   @failingTest
-  test_const_invokeConstructor_generic_noTypeArguments() async {
-    await super.test_const_invokeConstructor_generic_noTypeArguments();
-  }
-
-  @failingTest
-  test_const_invokeConstructor_generic_unnamed() async {
-    await super.test_const_invokeConstructor_generic_unnamed();
-  }
-
-  @failingTest
   test_const_invokeConstructor_generic_unnamed_imported() async {
     await super.test_const_invokeConstructor_generic_unnamed_imported();
   }
 
   @failingTest
   test_const_invokeConstructor_generic_unnamed_imported_withPrefix() async {
     await super
         .test_const_invokeConstructor_generic_unnamed_imported_withPrefix();
   }
 
   @failingTest
-  test_const_invokeConstructor_named() async {
-    await super.test_const_invokeConstructor_named();
-  }
-
-  @failingTest
   test_const_invokeConstructor_named_imported() async {
     await super.test_const_invokeConstructor_named_imported();
   }
 
   @failingTest
   test_const_invokeConstructor_named_imported_withPrefix() async {
     await super.test_const_invokeConstructor_named_imported_withPrefix();
   }
 
   @failingTest
@@ skipping 20 matching lines @@
   test_const_invokeConstructor_named_unresolved5() async {
     await super.test_const_invokeConstructor_named_unresolved5();
   }
 
   @failingTest
   test_const_invokeConstructor_named_unresolved6() async {
     await super.test_const_invokeConstructor_named_unresolved6();
   }
 
   @failingTest
-  test_const_invokeConstructor_unnamed() async {
-    await super.test_const_invokeConstructor_unnamed();
-  }
-
-  @failingTest
   test_const_invokeConstructor_unnamed_imported() async {
     await super.test_const_invokeConstructor_unnamed_imported();
   }
 
   @failingTest
   test_const_invokeConstructor_unnamed_imported_withPrefix() async {
     await super.test_const_invokeConstructor_unnamed_imported_withPrefix();
   }
 
   @failingTest
@@ skipping 1759 matching lines @@
             }
           } else if (args.length == 1) {
             var operator = _toBinaryOperatorTokenType(operatorName);
             var right = build(args.single);
             return AstTestFactory.binaryExpression(left, operator, right);
           }
         }
       }
     }
 
+    if (expr is kernel.ConstructorInvocation) {
+      var element = _getElement(expr.targetReference);
+
+      var kernelType = expr.getStaticType(_context._resynthesizer._types);
+      var type = _context.getType(null, kernelType);
+      TypeName typeName = _buildType(type);
+
+      var constructorName = AstTestFactory.constructorName(
+          typeName, element.name.isNotEmpty ? element.name : null);
+      constructorName?.name?.staticElement = element;
+
+      var keyword = expr.isConst ? Keyword.CONST : Keyword.NEW;
+      var arguments = _toArguments(expr.arguments);
+      return AstTestFactory.instanceCreationExpression(
+          keyword, constructorName, arguments);
+    }
+
     // TODO(scheglov): complete getExpression
     throw new UnimplementedError('kernel: (${expr.runtimeType}) $expr');
   }
 
   Expression _buildIdentifier(kernel.Reference reference, {bool isGet: false}) {
     Element element = _getElement(reference);
     if (isGet && element is PropertyInducingElement) {
       element = (element as PropertyInducingElement).getter;
     }
     SimpleIdentifier property = AstTestFactory.identifier3(element.displayName)
@@ skipping 56 matching lines @@
   }
 
   InterpolationElement _newInterpolationElement(Expression expr) {
     if (expr is SimpleStringLiteral) {
       return astFactory.interpolationString(expr.literal, expr.value);
     } else {
       return AstTestFactory.interpolationExpression(expr);
     }
   }
 
+  /// Return [Expression]s for the given [kernelArguments].
+  List<Expression> _toArguments(kernel.Arguments kernelArguments) {
+    int numPositional = kernelArguments.positional.length;
+    int numNamed = kernelArguments.named.length;
+    var arguments = new List<Expression>(numPositional + numNamed);
+
+    int i = 0;
+    for (kernel.Expression k in kernelArguments.positional) {
+      arguments[i++] = build(k);
+    }
+
+    for (kernel.NamedExpression k in kernelArguments.named) {
+      var value = build(k.value);
+      arguments[i++] = AstTestFactory.namedExpression2(k.name, value);
+    }
+
+    return arguments;
+  }
+
   /// Return the [TokenType] for the given operator [name].
   TokenType _toBinaryOperatorTokenType(String name) {
     if (name == '==') return TokenType.EQ_EQ;
     if (name == '&&') return TokenType.AMPERSAND_AMPERSAND;
     if (name == '||') return TokenType.BAR_BAR;
     if (name == '^') return TokenType.CARET;
     if (name == '&') return TokenType.AMPERSAND;
     if (name == '|') return TokenType.BAR;
     if (name == '>>') return TokenType.GT_GT;
     if (name == '<<') return TokenType.LT_LT;
@@ skipping 72 matching lines @@
 
   @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.DynamicType) return DynamicTypeImpl.instance;
+    if (kernelType is kernel.VoidType) return VoidTypeImpl.instance;
     if (kernelType is kernel.InterfaceType) {
       return _getInterfaceType(
           kernelType.className.canonicalName, kernelType.typeArguments);
     }
-    if (kernelType is kernel.VoidType) return VoidTypeImpl.instance;
+    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}');
   }
 
   /**
    * Return the [ElementImpl] that corresponds to the given [name], or `null`
    * if the corresponding element cannot be found.
    */
   ElementImpl _getElement(kernel.CanonicalName name) {
     if (name == null) return null;
     kernel.CanonicalName parentName = name.parent;
 
     // If the parent is the root, then this name is a library.
     if (parentName.isRoot) {
       return _resynthesizer.getLibrary(name.name);
     }
 
     // Skip qualifiers.
     bool isGetter = false;
     bool isSetter = false;
     bool isField = false;
+    bool isConstructor = false;
     bool isMethod = false;
     if (parentName.name == '@getters') {
       isGetter = true;
       parentName = parentName.parent;
     } else if (parentName.name == '@setters') {
       isSetter = true;
       parentName = parentName.parent;
     } else if (parentName.name == '@fields') {
       isField = true;
       parentName = parentName.parent;
+    } else if (parentName.name == '@constructors') {
+      isConstructor = true;
+      parentName = parentName.parent;
     } else if (parentName.name == '@methods') {
       isMethod = true;
       parentName = parentName.parent;
     }
 
     ElementImpl parentElement = _getElement(parentName);
     if (parentElement == null) return null;
 
     // Search in units of the library.
     if (parentElement is LibraryElementImpl) {
       for (CompilationUnitElement unit in parentElement.units) {
         CompilationUnitElementImpl unitImpl = unit;
         ElementImpl child = unitImpl.getChild(name.name);
         if (child != null) {
           return child;
         }
       }
       return null;
     }
 
     // Search in the class.
     if (parentElement is ClassElementImpl) {
       if (isGetter) {
         return parentElement.getGetter(name.name) as ElementImpl;
       } else if (isSetter) {
         return parentElement.getSetter(name.name) as ElementImpl;
       } else if (isField) {
         return parentElement.getField(name.name) as ElementImpl;
+      } else if (isConstructor) {
+        if (name.name.isEmpty) {
+          return parentElement.unnamedConstructor as ConstructorElementImpl;
+        }
+        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(
       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;
     });
   }
+
+  /// 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) {
+      if (ctx is TypeParameterizedElementMixin) {
+        for (var typeParameter in ctx.typeParameters) {
+          if (typeParameter.name == name) {
+            return typeParameter;
+          }
+        }
+      }
+    }
+    throw new StateError('Not found $kernelTypeParameter in $context');
+  }
 }
 
 class _KernelResynthesizer {
   final AnalysisContext _analysisContext;
+  final kernel.TypeEnvironment _types;
   final Map<String, kernel.Library> _kernelMap;
   final Map<String, LibraryElementImpl> _libraryMap = {};
 
   /**
    * Cache of [Source] objects that have already been converted from URIs.
    */
   final Map<String, Source> _sources = <String, Source>{};
 
-  _KernelResynthesizer(this._analysisContext, this._kernelMap);
+  _KernelResynthesizer(this._analysisContext, this._types, 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);
       Source librarySource = _getSource(uriStr);
       LibraryElementImpl libraryElement =
           new LibraryElementImpl.forKernel(_analysisContext, libraryContext);
       CompilationUnitElementImpl definingUnit =
           libraryElement.definingCompilationUnit;
       definingUnit.source = librarySource;
       definingUnit.librarySource = librarySource;
       return libraryElement;
     });
   }
 
   /**
    * Get the [Source] object for the given [uri].
    */
   Source _getSource(String uri) {
     return _sources.putIfAbsent(
         uri, () => _analysisContext.sourceFactory.forUri(uri));
   }
 }