Downward inference

lib/src/codegen/reify_coercions.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 dev_compiler.src.codegen.reify_coercions;
 
 import 'package:analyzer/analyzer.dart' as analyzer;
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:logging/logging.dart' as logger;
@@ skipping 15 matching lines @@
 }
 
 typedef T Function1<S, T>(S _);
 
 class _LocatedWrapper {
   final String loc;
   final Wrapper wrapper;
   _LocatedWrapper(this.wrapper, this.loc);
 }
 
+class _Inference extends DownwardsInference {
+  TypeManager _tm;
+
+  _Inference(TypeRules rules, this._tm) : super(rules);
+
+  @override
+  void annotateListLiteral(ListLiteral e, List<DartType> targs) {
+    var tNames = targs.map(_tm.typeNameFromDartType).toList();
+    e.typeArguments = AstBuilder.typeArgumentList(tNames);
+    var listT = rules.provider.listType.substitute4(targs);
+    e.staticType = listT;
+  }
+
+  @override
+  void annotateMapLiteral(MapLiteral e, List<DartType> targs) {
+    var tNames = targs.map(_tm.typeNameFromDartType).toList();
+    e.typeArguments = AstBuilder.typeArgumentList(tNames);
+    var mapT = rules.provider.mapType.substitute4(targs);
+    e.staticType = mapT;
+  }
+
+  @override
+  void annotateInstanceCreationExpression(
+      InstanceCreationExpression e, List<DartType> targs) {
+    var tNames = targs.map(_tm.typeNameFromDartType).toList();
+    var cName = e.constructorName;
+    var id = cName.type.name;
+    var typeName = AstBuilder.typeName(id, tNames);
+    cName.type = typeName;
+    var rawType = (e.staticType.element as ClassElement).type;
+    e.staticType = rawType.substitute4(targs);
+  }
+}
+
 // This class implements a pass which modifies (in place) the ast replacing
 // abstract coercion nodes with their dart implementations.
 class UnitCoercionReifier extends analyzer.GeneralizingAstVisitor<Object>
     with ConversionVisitor<Object> {
   CoercionManager _cm;
   final TypeManager _tm;
   final VariableManager _vm;
   SourceFile _file;
   bool _skipCoercions = false;
   final TypeRules _rules;
+  _Inference _inferrer;
 
   UnitCoercionReifier(this._tm, this._vm, this._rules) {
     _cm = new CoercionManager(_vm, _tm, _rules);
+    _inferrer = new _Inference(_rules, _tm);
   }
 
   // This should be the entry point for this class.  Entering via the
   // visit functions directly may not do the right thing with respect
   // to discharging the collected definitions.
   void reify(CompilationUnit unit) {
     _file = new SourceFile(unit.element.source.contents.data,
         url: unit.element.source.uri);
     visitCompilationUnit(unit);
   }
@@ skipping 12 matching lines @@
       }
     }
     return null;
   }
 
   static String _conversionKind(Conversion node) {
     if (node is ClosureWrapLiteral) return "WrapLiteral";
     if (node is ClosureWrap) return "Wrap";
     if (node is DynamicCast) return "DynamicCast";
     if (node is AssignmentCast) return "AssignmentCast";
-    if (node is InferableLiteral) return "InferableLiteral";
     if (node is InferableClosure) return "InferableClosure";
-    if (node is InferableAllocation) return "InferableAllocation";
     if (node is DownCastComposite) return "CompositeCast";
     if (node is DownCastImplicit) return "ImplicitCast";
     assert(false);
     return "";
   }
 
   @override
   Object visitAsExpression(AsExpression e) {
     var cast = Coercion.cast(_rules.getStaticType(e.expression), e.type.type);
     var loc = _locationInfo(e);
     Expression castNode =
         _cm.coerceExpression(e.expression, cast, "CastUser", loc);
     if (!NodeReplacer.replace(e, castNode)) {
       _log.severe("Failed to replace node for DownCast");
     }
     castNode.accept(this);
     return null;
   }
 
   @override
+  Object visitInferredTypeBase(InferredTypeBase node) {
+    var expr = node.node;
+    var b = _inferrer.inferExpression(expr, node.type);
+    assert(b);
+    if (!NodeReplacer.replace(node, expr)) {
+      _log.severe("Failed to replace node for InferredType");
+    }
+    expr.accept(this);
+    return null;
+  }
+
+  @override
   Object visitDownCast(DownCast node) {
     if (_skipCoercions) {
       _log.severe("Skipping runtime downcast in constant context");
       return null;
     }
     String kind = _conversionKind(node);
     var loc = _locationInfo(node);
     Expression castNode = _cm.coerceExpression(node.node, node.cast, kind, loc);
     if (!NodeReplacer.replace(node, castNode)) {
       _log.severe("Failed to replace node for DownCast");
@@ skipping 546 matching lines @@
   Expression _typeExpression(TypeName t) {
     if (t.typeArguments != null && t.typeArguments.length > 0) {
       var w = AstBuilder.identifierFromString("_");
       var fp = AstBuilder.simpleFormal(w, t);
       var f = AstBuilder.blockFunction(<FormalParameter>[fp], <Statement>[]);
       return new RuntimeOperation("type", <Expression>[f]);
     }
     return t.name;
   }
 }