Resynthesize assert constructor initializers and parameter references.

pkg/analyzer/lib/src/kernel/resynthesize.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 '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/src/dart/element/element.dart';
@@ skipping 211 matching lines @@
       return _buildIdentifier(expr.targetReference, isGet: true);
     }
 
     if (expr is kernel.PropertyGet) {
       Expression target = build(expr.receiver);
       kernel.Reference reference = expr.interfaceTargetReference;
       SimpleIdentifier identifier = _buildSimpleIdentifier(reference);
       return AstTestFactory.propertyAccess(target, identifier);
     }
 
+    if (expr is kernel.VariableGet) {
+      String name = expr.variable.name;
+      Element contextConstructor = _contextElement;
+      if (contextConstructor is ConstructorElement) {
+        SimpleIdentifier identifier = AstTestFactory.identifier3(name);
+        ParameterElement parameter = contextConstructor.parameters.firstWhere(
+            (parameter) => parameter.name == name,
+            orElse: () => null);
+        identifier.staticElement = parameter;
+        return identifier;
+      }
+    }
+
     if (expr is kernel.ConditionalExpression) {
       var condition = build(expr.condition);
       var then = build(expr.then);
       var otherwise = build(expr.otherwise);
       return AstTestFactory.conditionalExpression(condition, then, otherwise);
     }
 
     if (expr is kernel.Not) {
       kernel.Expression kernelOperand = expr.operand;
       var operand = build(kernelOperand);
@@ skipping 72 matching lines @@
 
   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.LocalInitializer) {
+      var invocation = k.variable.initializer;
+      if (invocation is kernel.MethodInvocation) {
+        var receiver = invocation.receiver;
+        if (receiver is kernel.FunctionExpression &&
+            invocation.name.name == 'call') {
+          var body = receiver.function.body;
+          if (body is kernel.AssertStatement) {
+            var condition = build(body.condition);
+            var message = body.message != null ? build(body.message) : null;
+            return AstTestFactory.assertInitializer(condition, message);
+          }
+        }
+      }
+      return null;

[Paul Berry, 2017/08/15 16:54:39]

Do we ever expect to reach this?  Does the caller propery handle a return value
of `null`?

If the answer to either question is no, then we should probably throw an
exception here.  Or if you think that's too dangerous, then maybe an assertion,
so that at least we have a chance of discovering the bug during testing.

[scheglov, 2017/08/23 17:06:27]

Done.

+    }
+
     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) {
@@ skipping 313 matching lines @@
         variablesData.implicitAccessors
             .add(new PropertyAccessorElementImpl_ImplicitSetter(variable));
       }
     }
     return variablesData;
   }
 
   @override
   ConstructorInitializer getConstructorInitializer(
       ConstructorElementImpl constructor, kernel.Initializer k) {
-    if (k is kernel.LocalInitializer ||
-        k is kernel.FieldInitializer && k.isSynthetic ||
+    if (k is kernel.FieldInitializer && k.isSynthetic ||
         k is kernel.SuperInitializer && k.isSynthetic) {
       return null;
     }
     return new _ExprBuilder(this, constructor).buildInitializer(k);
   }
 
   @override
   Expression getExpression(ElementImpl context, kernel.Expression expression) {
     return new _ExprBuilder(this, context).build(expression);
   }
@@ skipping 146 matching lines @@
         for (var typeParameter in ctx.typeParameters) {
           if (typeParameter.name == name) {
             return typeParameter;
           }
         }
       }
     }
     throw new StateError('Not found $kernelTypeParameter in $context');
   }
 }