Resynthesize untyped List / Map.

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 245 matching lines @@
   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:
           _push(AstFactory.nullLiteral());
           break;
         // bool
         case UnlinkedConstOperation.pushFalse:
           _push(AstFactory.booleanLiteral(false));
           break;
         case UnlinkedConstOperation.pushTrue:
@@ skipping 109 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;
-        // TODO(scheglov) complete implementation
         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));
+          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));
+          break;
         case UnlinkedConstOperation.makeTypedList:
-        case UnlinkedConstOperation.makeUntypedMap:
         case UnlinkedConstOperation.makeTypedMap:
         case UnlinkedConstOperation.pushReference:
         case UnlinkedConstOperation.invokeConstructor:
         case UnlinkedConstOperation.length:
           return AstFactory.nullLiteral();
 //          throw new StateError('Unsupported constant operation $operation');
       }
     }
     return stack.single;
   }
@@ skipping 1180 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;
     }
   }
 }