Resynthesize typed constant lists and maps.

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';
@@ skipping 231 matching lines @@
       return true;
     }
     return hasLibrarySummary(uri);
   }
 }
 
 /**
  * Builder of [Expression]s from [UnlinkedConst]s.
  */
 class _ConstExprBuilder {
-  final SummaryResynthesizer resynthesizer;
+  final _LibraryResynthesizer 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);
 
@@ skipping 124 matching lines @@
               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;
         case UnlinkedConstOperation.makeUntypedList:
-          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, null, elements));
+          _pushList(null);
+          break;
+        case UnlinkedConstOperation.makeTypedList:
+          TypeName itemType = _newTypeName();
+          _pushList(AstFactory.typeArgumentList(<TypeName>[itemType]));
           break;
         case UnlinkedConstOperation.makeUntypedMap:
-          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, null, entries));
+          _pushMap(null);
           break;
-        case UnlinkedConstOperation.makeTypedList:
         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;
+    } else if (type is InterfaceType) {
+      List<TypeName> argumentNodes =
+          type.typeArguments.map(_buildTypeAst).toList();
+      TypeName node = AstFactory.typeName4(type.name, argumentNodes);
+      node.type = type;
+      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(
           TokenFactory.tokenFromType(TokenType.STRING_INTERPOLATION_EXPRESSION),
           expr,
           TokenFactory.tokenFromType(TokenType.CLOSE_CURLY_BRACKET));
     }
   }
 
+  /**
+   * Convert the next reference to the [DartType] and return the AST
+   * corresponding to this type.
+   */
+  TypeName _newTypeName() {
+    EntityRef typeRef = uc.references[refPtr++];
+    DartType type = resynthesizer.buildType(typeRef);
+    return _buildTypeAst(type);
+  }
+
   Expression _pop() => stack.removeLast();
 
   void _push(Expression expr) {
     stack.add(expr);
   }
 
   void _pushBinary(TokenType operator) {
     Expression right = _pop();
     Expression left = _pop();
     _push(AstFactory.binaryExpression(left, operator, right));
   }
 
+  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 _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
@@ skipping 859 matching lines @@
   void buildVariable(UnlinkedVariable serializedVariable,
       [ElementHolder holder]) {
     if (holder == null) {
       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);
+        _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 {
@@ skipping 265 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;
     }
   }
 }