Resynthesize constructor initializers 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';
@@ skipping 392 matching lines @@
   test_constructor_initializers_assertInvocation() async {
     await super.test_constructor_initializers_assertInvocation();
   }
 
   @failingTest
   test_constructor_initializers_assertInvocation_message() async {
     await super.test_constructor_initializers_assertInvocation_message();
   }
 
   @failingTest
-  test_constructor_initializers_field() async {
-    await super.test_constructor_initializers_field();
-  }
-
-  @failingTest
+  @_fastaProblem
   test_constructor_initializers_field_notConst() async {
+    // Fasta generates additional `#errors` top-level variable.
     await super.test_constructor_initializers_field_notConst();
   }
 
   @failingTest
+  @_fastaProblem
   test_constructor_initializers_field_withParameter() async {
+    // https://github.com/dart-lang/sdk/issues/30251
     await super.test_constructor_initializers_field_withParameter();
   }
 
   @failingTest
-  test_constructor_initializers_superInvocation_named() async {
-    await super.test_constructor_initializers_superInvocation_named();
-  }
-
-  @failingTest
-  test_constructor_initializers_superInvocation_namedExpression() async {
-    await super.test_constructor_initializers_superInvocation_namedExpression();
-  }
-
-  @failingTest
-  test_constructor_initializers_superInvocation_unnamed() async {
-    await super.test_constructor_initializers_superInvocation_unnamed();
-  }
-
-  @failingTest
-  test_constructor_initializers_thisInvocation_named() async {
-    await super.test_constructor_initializers_thisInvocation_named();
-  }
-
-  @failingTest
-  test_constructor_initializers_thisInvocation_namedExpression() async {
-    await super.test_constructor_initializers_thisInvocation_namedExpression();
-  }
-
-  @failingTest
-  test_constructor_initializers_thisInvocation_unnamed() async {
-    await super.test_constructor_initializers_thisInvocation_unnamed();
-  }
-
-  @failingTest
   test_constructor_redirected_factory_named() async {
     await super.test_constructor_redirected_factory_named();
   }
 
   @failingTest
   test_constructor_redirected_factory_named_generic() async {
     await super.test_constructor_redirected_factory_named_generic();
   }
 
   @failingTest
@@ skipping 76 matching lines @@
   test_constructor_redirected_thisInvocation_unnamed() async {
     await super.test_constructor_redirected_thisInvocation_unnamed();
   }
 
   @failingTest
   test_constructor_redirected_thisInvocation_unnamed_generic() async {
     await super.test_constructor_redirected_thisInvocation_unnamed_generic();
   }
 
   @failingTest
-  test_constructor_withCycles_const() async {
-    await super.test_constructor_withCycles_const();
-  }
-
-  @failingTest
   test_defaultValue_refersToGenericClass_constructor() async {
     await super.test_defaultValue_refersToGenericClass_constructor();
   }
 
   @failingTest
   test_defaultValue_refersToGenericClass_constructor2() async {
     await super.test_defaultValue_refersToGenericClass_constructor2();
   }
 
   @failingTest
@@ skipping 370 matching lines @@
   test_import_show() async {
     await super.test_import_show();
   }
 
   @failingTest
   test_inferred_function_type_for_variable_in_generic_function() async {
     await super.test_inferred_function_type_for_variable_in_generic_function();
   }
 
   @failingTest
+  test_inferred_function_type_in_generic_class_constructor() async {
+    await super.test_inferred_function_type_in_generic_class_constructor();
+  }
+
+  @failingTest
   test_inferred_function_type_in_generic_class_in_generic_method() async {
     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();
   }
 
@@ skipping 948 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.StaticInvocation) {
+      kernel.Procedure target = expr.target;
+      String name = target.name.name;
+      List<Expression> arguments = _toArguments(expr.arguments);
+      MethodInvocation invocation =
+          AstTestFactory.methodInvocation3(null, name, null, arguments);
+      invocation.methodName.staticElement = _getElement(target.reference);
+      return invocation;
+    }
+
     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');
   }
 
+  ConstructorInitializer buildInitializer(kernel.Initializer k) {
+    if (k is kernel.FieldInitializer) {
+      Expression value = build(k.value);
+      ConstructorFieldInitializer initializer = AstTestFactory
+          .constructorFieldInitializer(false, k.field.name.name, value);
+      initializer.fieldName.staticElement = _getElement(k.fieldReference);
+      return initializer;
+    }
+
+    if (k is kernel.RedirectingInitializer) {
+      ConstructorElementImpl redirect = _getElement(k.targetReference);
+      var arguments = _toArguments(k.arguments);
+
+      RedirectingConstructorInvocation invocation =
+          AstTestFactory.redirectingConstructorInvocation(arguments);
+      invocation.staticElement = redirect;
+
+      String name = k.target.name.name;
+      if (name.isNotEmpty) {
+        invocation.constructorName = AstTestFactory.identifier3(name)
+          ..staticElement = redirect;
+      }
+
+      return invocation;
+    }
+
+    if (k is kernel.SuperInitializer) {
+      ConstructorElementImpl redirect = _getElement(k.targetReference);
+      var arguments = _toArguments(k.arguments);
+
+      SuperConstructorInvocation invocation =
+          AstTestFactory.superConstructorInvocation(arguments);
+      invocation.staticElement = redirect;
+
+      String name = k.target.name.name;
+      if (name.isNotEmpty) {
+        invocation.constructorName = AstTestFactory.identifier3(name)
+          ..staticElement = redirect;
+      }
+
+      return invocation;
+    }
+
+    // TODO(scheglov) Support other kernel initializer types.
+    throw new UnimplementedError('For ${k.runtimeType}');
+  }
+
   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)
       ..staticElement = element;
     Element enclosingElement = element.enclosingElement;
     if (enclosingElement is ClassElement) {
       SimpleIdentifier classRef = AstTestFactory
@@ skipping 135 matching lines @@
   Future<List<int>> readAsBytes() async {
     return file.readAsBytesSync();
   }
 
   @override
   Future<String> readAsString() async {
     return file.readAsStringSync();
   }
 }
 
 class _KernelLibraryResynthesizerContextImpl

[Siggi Cherem (dart-lang), 2017/07/25 15:19:56]

question unrelated to the CL: what is your plan with this context class later
on? Is the plan to move it out of this test file into the lib dir eventually? To
implement it based on ast_builder? Or something else?
 

[scheglov, 2017/07/25 16:15:54]

Yes, the plan is to extract these classes into a separate file in analyzer/lib.

     implements KernelLibraryResynthesizerContext {
   final _KernelResynthesizer _resynthesizer;
 
   @override
   final kernel.Library library;
 
   _KernelLibraryResynthesizerContextImpl(this._resynthesizer, this.library);
 
   @override
+  ConstructorInitializer getConstructorInitializer(
+      ConstructorElementImpl constructor, kernel.Initializer k) {
+    if (k is kernel.LocalInitializer ||
+        k is kernel.FieldInitializer && k.isSynthetic ||
+        k is kernel.SuperInitializer && k.isSynthetic) {
+      return null;
+    }
+    return new _ExprBuilder(this).buildInitializer(k);
+  }
+
+  @override
+  ElementImpl getElement(kernel.Reference reference) {
+    return _getElement(reference.canonicalName);
+  }
+
+  @override
   Expression getExpression(kernel.Expression expression) {
     return new _ExprBuilder(this).build(expression);
   }
 
   @override
   InterfaceType getInterfaceType(
       ElementImpl context, kernel.Supertype kernelType) {
     return _getInterfaceType(
         context, kernelType.className.canonicalName, kernelType.typeArguments);
   }
@@ skipping 24 matching lines @@
    */
   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);
     }
 
+    // If the name is private, it is prefixed with a library URI.
+    if (name.name.startsWith('_')) {
+      parentName = parentName.parent;
+    }
+
     // 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') {
@@ skipping 115 matching lines @@
   }
 
   /**
    * Get the [Source] object for the given [uri].
    */
   Source _getSource(String uri) {
     return _sources.putIfAbsent(
         uri, () => _analysisContext.sourceFactory.forUri(uri));
   }
 }