Resynthesize metadata from Kernel, when already supported.

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 366 matching lines @@
 class _KernelLibraryResynthesizerContextImpl
     implements KernelLibraryResynthesizerContext {
   final KernelResynthesizer _resynthesizer;
 
   @override
   final kernel.Library library;
 
   _KernelLibraryResynthesizerContextImpl(this._resynthesizer, this.library);
 
   @override
+  List<ElementAnnotation> buildAnnotations(
+      CompilationUnitElementImpl unit, List<kernel.Expression> expressions) {
+    int length = expressions.length;
+    if (length != 0) {
+      var annotations = new List<ElementAnnotation>(length);
+      for (int i = 0; i < length; i++) {
+        annotations[i] = _buildAnnotation(unit, expressions[i]);
+      }
+      return annotations;
+    } else {
+      return const <ElementAnnotation>[];
+    }
+  }
+
+  @override
   UnitExplicitTopLevelAccessors buildTopLevelAccessors(
       CompilationUnitElementImpl unit) {
     var accessorsData = new UnitExplicitTopLevelAccessors();
     var implicitVariables = <String, TopLevelVariableElementImpl>{};
     // Build explicit property accessors and implicit fields.
     for (var procedure in library.procedures) {
       bool isGetter = procedure.kind == kernel.ProcedureKind.Getter;
       bool isSetter = procedure.kind == kernel.ProcedureKind.Setter;
       if (isGetter || isSetter) {
         var accessor =
@@ skipping 140 matching lines @@
 
       functionElement.returnType =
           getType(functionElement, kernelType.returnType);
       return functionElement.type;
     }
 
     // TODO(scheglov) Support other kernel types.
     throw new UnimplementedError('For ${kernelType.runtimeType}');
   }
 
+  ElementAnnotationImpl _buildAnnotation(
+      CompilationUnitElementImpl unit, kernel.Expression expression) {
+    ElementAnnotationImpl elementAnnotation = new ElementAnnotationImpl(unit);
+    Expression constExpr = getExpression(expression);
+    if (constExpr is Identifier) {
+      elementAnnotation.element = constExpr.staticElement;
+      elementAnnotation.annotationAst = AstTestFactory.annotation(constExpr);
+    } else if (constExpr is InstanceCreationExpression) {
+      elementAnnotation.element = constExpr.staticElement;
+      Identifier typeName = constExpr.constructorName.type.name;
+      SimpleIdentifier constructorName = constExpr.constructorName.name;
+      elementAnnotation.annotationAst = AstTestFactory.annotation2(
+          typeName, constructorName, constExpr.argumentList)
+        ..element = constExpr.staticElement;
+    } else {
+      throw new StateError(
+          'Unexpected annotation type: ${constExpr.runtimeType}');
+    }
+    return elementAnnotation;
+  }
+
   /**
    * 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) {
@@ skipping 93 matching lines @@
         for (var typeParameter in ctx.typeParameters) {
           if (typeParameter.name == name) {
             return typeParameter;
           }
         }
       }
     }
     throw new StateError('Not found $kernelTypeParameter in $context');
   }
 }