Compute literal constant values.

pkg/analyzer/lib/src/summary/resynthesize.dart

 // Copyright (c) 2015, 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 summary_resynthesizer;
 
 import 'dart:collection';
 
+import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
+import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element_handle.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
+import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source_io.dart';
+import 'package:analyzer/src/generated/testing/ast_factory.dart';
+import 'package:analyzer/src/generated/testing/token_factory.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/format.dart';
+import 'package:analyzer/src/task/dart.dart' show ConstantEvaluationTarget;
 
 /**
  * Implementation of [ElementResynthesizer] used when resynthesizing an element
  * model from summaries.
  */
 abstract class SummaryResynthesizer extends ElementResynthesizer {
   /**
    * The parent [SummaryResynthesizer] which is asked to resynthesize elements
    * and get summaries before this resynthesizer attempts to do this.
    * Can be `null`.
@@ skipping 204 matching lines @@
    */
   bool _hasLibrarySummary(String uri) {
     if (parent != null && parent._hasLibrarySummary(uri)) {
       return true;
     }
     return hasLibrarySummary(uri);
   }
 }
 
 /**
+ * Builder of [Expression]s from [UnlinkedConst]s.
+ */
+class _ConstExprBuilder {
+  final SummaryResynthesizer resynthesizer;
+  final UnlinkedConst uc;
+
+  int intPtr = 0;
+  int doublePtr = 0;
+  int stringPtr = 0;
+  int refPtr = 0;
+  final List<Expression> stack = <Expression>[];
+
+  _ConstExprBuilder(this.resynthesizer, this.uc);
+
+  Expression get expr => stack.single;
+
+  Expression build() {
+    // TODO(scheglov) complete implementation
+    for (UnlinkedConstOperation operation in uc.operations) {
+      switch (operation) {
+        case UnlinkedConstOperation.pushNull:
+          stack.add(AstFactory.nullLiteral());
+          break;
+        case UnlinkedConstOperation.pushFalse:
+          stack.add(AstFactory.booleanLiteral(false));
+          break;
+        case UnlinkedConstOperation.pushTrue:
+          stack.add(AstFactory.booleanLiteral(true));
+          break;
+        case UnlinkedConstOperation.pushInt:
+          int value = uc.ints[intPtr++];
+          stack.add(AstFactory.integer(value));
+          break;
+        case UnlinkedConstOperation.pushDouble:
+          double value = uc.doubles[doublePtr++];
+          stack.add(AstFactory.doubleLiteral(value));
+          break;
+        case UnlinkedConstOperation.pushString:
+          String value = uc.strings[stringPtr++];
+          stack.add(AstFactory.string2(value));
+          break;
+        case UnlinkedConstOperation.concatenate:
+          int count = uc.ints[intPtr++];
+          List<InterpolationElement> elements = <InterpolationElement>[];
+          for (int i = 0; i < count; i++) {
+            Expression expr = stack.removeLast();
+            InterpolationElement element = _newInterpolationElement(expr);
+            elements.insert(0, element);
+          }
+          stack.add(AstFactory.string(elements));
+          break;
+        default:
+          return AstFactory.nullLiteral();
+//          throw new StateError('Unsupported constant operation $operation');
+      }
+    }
+    return stack.single;
+  }
+
+  InterpolationElement _newInterpolationElement(Expression expr) {
+    if (expr is SimpleStringLiteral) {
+      return new InterpolationString(expr.literal, expr.value);
+    } else {
+      return new InterpolationExpression(
+          TokenFactory.tokenFromType(TokenType.STRING_INTERPOLATION_EXPRESSION),
+          expr,
+          TokenFactory.tokenFromType(TokenType.CLOSE_CURLY_BRACKET));
+    }
+  }
+}
+
+/**
+ * A single constant variable for which the constant value should be computed.
+ *
+ * TODO(scheglov) we will probably need to add dependency list
+ */
+class _ConstVariable {
+  final ConstVariableElement element;
+
+  _ConstVariable(this.element);
+}
+
+/**
  * An instance of [_LibraryResynthesizer] is responsible for resynthesizing the
  * elements in a single library from that library's summary.
  */
 class _LibraryResynthesizer {
   /**
    * The [SummaryResynthesizer] which is being used to obtain summaries.
    */
   final SummaryResynthesizer summaryResynthesizer;
 
   /**
@@ skipping 64 matching lines @@
    */
   List<TypeParameterElement> currentTypeParameters = <TypeParameterElement>[];
 
   /**
    * If a class is currently being resynthesized, map from field name to the
    * corresponding field element.  This is used when resynthesizing
    * initializing formal parameters.
    */
   Map<String, FieldElementImpl> fields;
 
+  /**
+   * List of constant variables to compute values for.
+   */
+  List<_ConstVariable> constVariables = <_ConstVariable>[];
+
   _LibraryResynthesizer(this.summaryResynthesizer, this.linkedLibrary,
       this.unlinkedUnits, this.librarySource) {
     isCoreLibrary = librarySource.uri.toString() == 'dart:core';
   }
 
   /**
    * Return a list of type arguments corresponding to [currentTypeParameters].
    */
   List<TypeParameterType> get currentTypeArguments => currentTypeParameters
       ?.map((TypeParameterElement param) => param.type)
@@ skipping 553 matching lines @@
       library.entryPoint = entryPoint;
     }
     // Create the synthetic element for `loadLibrary`.
     // Until the client received dart:core and dart:async, we cannot do this,
     // because the TypeProvider is not fully initialized. So, it is up to the
     // Dart SDK client to initialize TypeProvider and finish the dart:core and
     // dart:async libraries creation.
     if (library.name != 'dart.core' && library.name != 'dart.async') {
       library.createLoadLibraryFunction(summaryResynthesizer.typeProvider);
     }
+    // Compute constants.
+    for (_ConstVariable constVariable in constVariables) {
+      AnalysisContext context = summaryResynthesizer.context;
+      ConstantEvaluationEngine constantEvaluationEngine =
+          new ConstantEvaluationEngine(
+              summaryResynthesizer.typeProvider, context.declaredVariables,
+              typeSystem: context.typeSystem);
+      ConstantEvaluationTarget constTarget =
+          constVariable.element as ConstantEvaluationTarget;
+      constantEvaluationEngine.computeConstantValue(constTarget);
+    }
     // Done.
     return library;
   }
 
   /**
    * Build the appropriate [DartType] object corresponding to a slot id in the
    * [LinkedUnit.types] table.
    */
   DartType buildLinkedType(int slot) {
     if (slot == 0) {
@@ skipping 88 matching lines @@
     if (type == null) {
       if (defaultVoid) {
         return VoidTypeImpl.instance;
       } else {
         return summaryResynthesizer.typeProvider.dynamicType;
       }
     }
     if (type.paramReference != 0) {
       // TODO(paulberry): make this work for generic methods.
       return currentTypeParameters[
-          currentTypeParameters.length - type.paramReference].type;
+              currentTypeParameters.length - type.paramReference]
+          .type;
     } else {
       LinkedReference referenceResolution =
           linkedUnit.references[type.reference];
       String name;
       if (type.reference < unlinkedUnit.references.length) {
         name = unlinkedUnit.references[type.reference].name;
       } else {
         name = referenceResolution.name;
       }
       ElementLocationImpl location;
@@ skipping 101 matching lines @@
     typeParameterElement.type = new TypeParameterTypeImpl(typeParameterElement);
     return typeParameterElement;
   }
 
   /**
    * Resynthesize a [TopLevelVariableElement] or [FieldElement].
    */
   void buildVariable(UnlinkedVariable serializedVariable,
       [ElementHolder holder]) {
     if (holder == null) {
-      TopLevelVariableElementImpl element = new TopLevelVariableElementImpl(
-          serializedVariable.name, serializedVariable.nameOffset);
+      TopLevelVariableElementImpl element;
+      if (serializedVariable.constExpr != null) {
+        ConstTopLevelVariableElementImpl constElement =
+            new ConstTopLevelVariableElementImpl(
+                serializedVariable.name, serializedVariable.nameOffset);
+        element = constElement;
+        // TODO(scheglov) share const builder?
+        _ConstExprBuilder builder = new _ConstExprBuilder(
+            summaryResynthesizer, serializedVariable.constExpr);
+        constElement.constantInitializer = builder.build();
+        constVariables.add(new _ConstVariable(constElement));
+      } else {
+        element = new TopLevelVariableElementImpl(
+            serializedVariable.name, serializedVariable.nameOffset);
+      }
       buildVariableCommonParts(element, serializedVariable);
       unitHolder.addTopLevelVariable(element);
       buildImplicitAccessors(element, unitHolder);
     } else {
       FieldElementImpl element = new FieldElementImpl(
           serializedVariable.name, serializedVariable.nameOffset);
       buildVariableCommonParts(element, serializedVariable);
       element.static = serializedVariable.isStatic;
       holder.addField(element);
       buildImplicitAccessors(element, holder);
@@ skipping 100 matching lines @@
     for (PropertyAccessorElementImpl accessor in unit.accessors) {
       elementMap[accessor.identifier] = accessor;
     }
     resummarizedElements[absoluteUri] = elementMap;
     unitHolder = null;
     linkedUnit = null;
     unlinkedUnit = null;
     linkedTypeMap = null;
   }
 }