Verify AST instead of 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 275 matching lines @@
             Expression expr = _pop();
             InterpolationElement element = _newInterpolationElement(expr);
             elements.insert(0, element);
           }
           _push(AstFactory.string(elements));
           break;
         // binary
         case UnlinkedConstOperation.equal:
           _pushBinary(TokenType.EQ_EQ);
           break;
+        case UnlinkedConstOperation.notEqual:
+          _pushBinary(TokenType.BANG_EQ);
+          break;
         case UnlinkedConstOperation.and:
           _pushBinary(TokenType.AMPERSAND_AMPERSAND);
           break;
         case UnlinkedConstOperation.or:
           _pushBinary(TokenType.BAR_BAR);
           break;
         case UnlinkedConstOperation.bitXor:
           _pushBinary(TokenType.CARET);
           break;
         case UnlinkedConstOperation.bitAnd:
@@ skipping 56 matching lines @@
           _push(
               AstFactory.conditionalExpression(condition, thenExpr, elseExpr));
           break;
         // identical
         case UnlinkedConstOperation.identical:
           Expression second = _pop();
           Expression first = _pop();
           _push(AstFactory.methodInvocation(
               null, 'identical', <Expression>[first, second]));
           break;
+        // containers
         case UnlinkedConstOperation.makeUntypedList:
           _pushList(null);
           break;
         case UnlinkedConstOperation.makeTypedList:
           TypeName itemType = _newTypeName();
           _pushList(AstFactory.typeArgumentList(<TypeName>[itemType]));
           break;
         case UnlinkedConstOperation.makeUntypedMap:
           _pushMap(null);
           break;
         case UnlinkedConstOperation.makeTypedMap:
           TypeName keyType = _newTypeName();
           TypeName valueType = _newTypeName();
           _pushMap(AstFactory.typeArgumentList(<TypeName>[keyType, valueType]));
           break;
         case UnlinkedConstOperation.pushReference:
         case UnlinkedConstOperation.invokeConstructor:
         case UnlinkedConstOperation.length:
           return AstFactory.nullLiteral();
 //          throw new StateError('Unsupported constant operation $operation');
       }
     }
     return stack.single;
   }
 
-  void _pushMap(TypeArgumentList typeArguments) {
-    int count = uc.ints[intPtr++];
-    List<MapLiteralEntry> entries = <MapLiteralEntry>[];
-    for (int i = 0; i < count; i++) {
-      Expression value = _pop();
-      Expression key = _pop();
-      entries.insert(0, AstFactory.mapLiteralEntry2(key, value));
-    }
-    _push(AstFactory.mapLiteral(Keyword.CONST, typeArguments, entries));
-  }
-
   TypeName _buildTypeAst(DartType type) {
     if (type is DynamicTypeImpl) {
-      return AstFactory.typeName4('dynamic')..type = type;
+      TypeName node = AstFactory.typeName4('dynamic');
+      node.type = type;
+      (node.name as SimpleIdentifier).staticElement = type.element;
+      return node;
     } else if (type is InterfaceType) {
       List<TypeName> argumentNodes =
           type.typeArguments.map(_buildTypeAst).toList();
       TypeName node = AstFactory.typeName4(type.name, argumentNodes);
       node.type = type;
+      (node.name as SimpleIdentifier).staticElement = type.element;
       return node;
     }
     throw new StateError('Unsupported type $type');
   }
 
   InterpolationElement _newInterpolationElement(Expression expr) {
     if (expr is SimpleStringLiteral) {
       return new InterpolationString(expr.literal, expr.value);
     } else {
       return new InterpolationExpression(
@@ skipping 27 matching lines @@
 
   void _pushList(TypeArgumentList typeArguments) {
     int count = uc.ints[intPtr++];
     List<Expression> elements = <Expression>[];
     for (int i = 0; i < count; i++) {
       elements.insert(0, _pop());
     }
     _push(AstFactory.listLiteral2(Keyword.CONST, typeArguments, elements));
   }
 
+  void _pushMap(TypeArgumentList typeArguments) {
+    int count = uc.ints[intPtr++];
+    List<MapLiteralEntry> entries = <MapLiteralEntry>[];
+    for (int i = 0; i < count; i++) {
+      Expression value = _pop();
+      Expression key = _pop();
+      entries.insert(0, AstFactory.mapLiteralEntry2(key, value));
+    }
+    _push(AstFactory.mapLiteral(Keyword.CONST, typeArguments, entries));
+  }
+
   void _pushPrefix(TokenType operator) {
     Expression operand = _pop();
     _push(AstFactory.prefixExpression(operator, operand));
   }
 }
 
 /**
- * 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 65 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>[];
-
-  /**
    * List of [_ReferenceInfo] objects describing the references in the current
    * compilation unit.
    */
   List<_ReferenceInfo> referenceInfos;
 
   _LibraryResynthesizer(this.summaryResynthesizer, this.linkedLibrary,
       this.unlinkedUnits, this.librarySource) {
     isCoreLibrary = librarySource.uri.toString() == 'dart:core';
   }
 
@@ skipping 557 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 166 matching lines @@
       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(this, 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);
@@ skipping 263 matching lines @@
       return new InterfaceTypeImpl.elementWithNameAndArgs(
           element, name, typeArguments);
     } else if (element is FunctionTypeAliasElementHandle) {
       return new FunctionTypeImpl.elementWithNameAndArgs(
           element, name, typeArguments, typeArguments.isNotEmpty);
     } else {
       return null;
     }
   }
 }