Resynthesize literal expressions from Kernel.

pkg/analyzer/lib/src/dart/element/element.dart

 // Copyright (c) 2014, 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.src.dart.element.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 1595 matching lines @@
       return _metadata ??= _buildAnnotations(
           library.definingCompilationUnit as CompilationUnitElementImpl,
           _unlinkedPart.annotations);
     }
     return super.metadata;
   }
 
   @override
   List<TopLevelVariableElement> get topLevelVariables {
     if (_kernelContext != null) {
-      return _variables ??= _kernelContext.library.fields
-          .map((k) => new TopLevelVariableElementImpl.forKernel(this, k))
-          .toList(growable: false);
+      return _variables ??= _kernelContext.library.fields.map((k) {
+        if (k.isConst && k.initializer != null) {
+          return new ConstTopLevelVariableElementImpl.forKernel(this, k);
+        } else {
+          return new TopLevelVariableElementImpl.forKernel(this, k);
+        }
+      }).toList(growable: false);
     }
     if (_unlinkedUnit != null) {
       if (_variables == null) {
         _explicitTopLevelAccessors ??=
             resynthesizerContext.buildTopLevelAccessors();
         _explicitTopLevelVariables ??=
             resynthesizerContext.buildTopLevelVariables();
         List<TopLevelVariableElementImpl> variables =
             <TopLevelVariableElementImpl>[];
         variables.addAll(_explicitTopLevelVariables.variables);
@@ skipping 745 matching lines @@
 class ConstTopLevelVariableElementImpl extends TopLevelVariableElementImpl
     with ConstVariableElement {
   /**
    * Initialize a newly created synthetic top-level variable element to have the
    * given [name] and [offset].
    */
   ConstTopLevelVariableElementImpl(String name, int offset)
       : super(name, offset);
 
   /**
+   * Initialize using the given kernel.
+   */
+  ConstTopLevelVariableElementImpl.forKernel(
+      ElementImpl enclosingElement, kernel.Field kernel)
+      : super.forKernel(enclosingElement, kernel);
+
+  /**
    * Initialize a newly created top-level variable element to have the given
    * [name].
    */
   ConstTopLevelVariableElementImpl.forNode(Identifier name)
       : super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
   ConstTopLevelVariableElementImpl.forSerialized(
@@ skipping 21 matching lines @@
    * Note that in correct Dart code, all constant variables must have
    * initializers.  However, analyzer also needs to handle incorrect Dart code,
    * in which case there might be some constant variables that lack
    * initializers.
    */
   Expression _constantInitializer;
 
   EvaluationResultImpl _evaluationResult;
 
   Expression get constantInitializer {
-    if (_constantInitializer == null && _unlinkedConst != null) {
-      _constantInitializer = enclosingUnit.resynthesizerContext
-          .buildExpression(this, _unlinkedConst);
+    if (_constantInitializer == null) {
+      if (_kernelInitializer != null) {
+        _constantInitializer =
+            enclosingUnit._kernelContext.getExpression(_kernelInitializer);
+      }
+      if (_unlinkedConst != null) {
+        _constantInitializer = enclosingUnit.resynthesizerContext
+            .buildExpression(this, _unlinkedConst);
+      }
     }
     return _constantInitializer;
   }
 
   void set constantInitializer(Expression constantInitializer) {
     _assertNotResynthesized(_unlinkedConst);
     _constantInitializer = constantInitializer;
   }
 
   EvaluationResultImpl get evaluationResult => _evaluationResult;
 
   void set evaluationResult(EvaluationResultImpl evaluationResult) {
     _evaluationResult = evaluationResult;
   }
 
   /**
+   * If this element is resynthesized from Kernel, return the Kernel
+   * initializer, otherwise return `null`.
+   */
+  kernel.Expression get _kernelInitializer;
+
+  /**
    * If this element is resynthesized from the summary, return the unlinked
    * initializer, otherwise return `null`.
    */
   UnlinkedExpr get _unlinkedConst;
 
   /**
    * Return a representation of the value of this variable, forcing the value
    * to be computed if it had not previously been computed, or `null` if either
    * this variable was not declared with the 'const' modifier or if the value of
    * this variable could not be computed because of errors.
@@ skipping 3207 matching lines @@
   }
 }
 
 /**
  * The kernel context in which a library is resynthesized.
  */
 abstract class KernelLibraryResynthesizerContext {
   kernel.Library get library;
 
   /**
+   * Return the [Expression] for the given kernel.
+   */
+  Expression getExpression(kernel.Expression expression);
+
+  /**
    * Return the [InterfaceType] for the given Kernel [type], or `null` if the
    * [type] does not correspond to an [InterfaceType].
    */
   InterfaceType getInterfaceType(ElementImpl context, kernel.Supertype type);
 
   /**
    * Return the [DartType] for the given Kernel [type], or `null` if the [type]
    * does not correspond to a [DartType].
    */
   DartType getType(ElementImpl context, kernel.DartType type);
@@ skipping 1693 matching lines @@
   TopLevelInferenceError get typeInferenceError {
     if (_unlinkedVariable != null) {
       return enclosingUnit.resynthesizerContext
           .getTypeInferenceError(_unlinkedVariable.inferredTypeSlot);
     }
     // We don't support type inference errors without linking.
     return null;
   }
 
   /**
+   * Subclasses need this getter, see [ConstVariableElement._kernelInitializer].
+   */
+  kernel.Expression get _kernelInitializer => _kernel?.initializer;
+
+  /**
    * Subclasses need this getter, see [ConstVariableElement._unlinkedConst].
    */
   UnlinkedExpr get _unlinkedConst => _unlinkedVariable?.initializer?.bodyExpr;
 }
 
 /**
  * A concrete implementation of a [ParameterElement].
  */
 class ParameterElementImpl extends VariableElementImpl
     with ParameterElementMixin
@@ skipping 407 matching lines @@
       return new SourceRange(
           _unlinkedParam.visibleOffset, _unlinkedParam.visibleLength);
     }
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
   /**
+   * Subclasses need this getter, see [ConstVariableElement._kernelInitializer].
+   */
+  kernel.Expression get _kernelInitializer => _kernel?.initializer;
+
+  /**
    * Subclasses need this getter, see [ConstVariableElement._unlinkedConst].
    */
   UnlinkedExpr get _unlinkedConst => _unlinkedParam?.initializer?.bodyExpr;
 
   @override
   T accept<T>(ElementVisitor<T> visitor) => visitor.visitParameterElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     String left = "";
@@ skipping 1455 matching lines @@
 
   @override
   DartObject computeConstantValue() => null;
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     _initializer?.accept(visitor);
   }
 }