Downward inference

lib/src/info.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.
 
 /// Defines static information collected by the type checker and used later by
 /// emitters to generate code.
 library dev_compiler.src.info;
 
 import 'dart:mirrors';
 
@@ skipping 219 matching lines @@
         assert(rules.maybeNonNullableType(toT));
         // TODO(vsm): Create a NullCast for this once we revisit nonnullability.
         return new DownCastImplicit(rules, expression, cast);
       }
     }
 
     // Inference "casts":
     if (expression is Literal) {
       // fromT should be an exact type - this will almost certainly fail at
       // runtime.
-      return new InferableLiteral(rules, expression, cast);
+      return new StaticTypeError(rules, expression, toT);
     }
     if (expression is FunctionExpression) {
       // fromT should be an exact type - this will almost certainly fail at
       // runtime.
       return new InferableClosure(rules, expression, cast);
     }
     if (expression is InstanceCreationExpression) {
       // fromT should be an exact type - this will almost certainly fail at
       // runtime.
-      return new InferableAllocation(rules, expression, cast);
+      return new StaticTypeError(rules, expression, toT);
     }
 
     // Composite cast: these are more likely to fail.
     if (!rules.isGroundType(toT)) {
       // This cast is (probably) due to our different treatment of dynamic.
       // It may be more likely to fail at runtime.
       return new DownCastComposite(rules, expression, cast);
     }
 
     // Dynamic cast
@@ skipping 46 matching lines @@
 //
 // Temporary "casts" of allocation sites - literals, constructor invocations,
 // and closures.  These should be handled by contextual inference.  In most
 // cases, inference will be sufficient, though in some it may unmask an actual
 // error: e.g.,
 //   List<int> l = [1, 2, 3]; // Inference succeeds
 //   List<String> l = [1, 2, 3]; // Inference reveals static type error
 // We're marking all as warnings for now.
 //
 
-// A "down cast" on a literal expression.
-class InferableLiteral extends DownCast {
-  InferableLiteral(TypeRules rules, Literal expression, Cast cast)
-      : super._internal(rules, expression, cast);
-
-  final Level level = Level.WARNING;
-}
-
 // A "down cast" on a closure literal.
 class InferableClosure extends DownCast {
   InferableClosure(TypeRules rules, FunctionExpression expression, Cast cast)
       : super._internal(rules, expression, cast);
 
   final Level level = Level.WARNING;
 }
 
-// A "down cast" on a non-literal allocation site.
-class InferableAllocation extends DownCast {
-  InferableAllocation(
-      TypeRules rules, InstanceCreationExpression expression, Cast cast)
-      : super._internal(rules, expression, cast);
-
-  final Level level = Level.WARNING;
-}
-
 //
 // Implicit down casts.  These are only injected by the compiler by flag.
 //
 
 // A down cast to a non-ground type.  These behave differently from standard
 // Dart and may be more likely to fail at runtime.
 class DownCastComposite extends DownCast {
   DownCastComposite(TypeRules rules, Expression expression, Cast cast)
       : super._internal(rules, expression, cast);
 
   final Level level = Level.WARNING;
 }
 
 // A down cast to a non-ground type.  These behave differently from standard
 // Dart and may be more likely to fail at runtime.
 class DownCastImplicit extends DownCast {
   DownCastImplicit(TypeRules rules, Expression expression, Cast cast)
       : super._internal(rules, expression, cast);
 
   final Level level = Level.WARNING;
 }
 
+// An inferred type for the wrapped expression, which may need to be
+// reified into the term
+abstract class InferredTypeBase extends Conversion {
+  DartType _type;
+
+  InferredTypeBase._internal(TypeRules rules, Expression expression, this._type)
+      : super(rules, expression);
+
+  DartType get type => _type;
+
+  DartType _getConvertedType() => type;
+
+  String get message => '$expression has inferred type $type';
+
+  Level get level => Level.INFO;
+
+  accept(AstVisitor visitor) {
+    if (visitor is ConversionVisitor) {
+      return visitor.visitInferredTypeBase(this);
+    } else {
+      return expression.accept(visitor);
+    }
+  }
+}
+
+// Standard / unspecialized inferred type
+class InferredType extends InferredTypeBase {
+  InferredType(TypeRules rules, Expression expression, DartType type)
+      : super._internal(rules, expression, type);
+
+  // Factory to create correct InferredType variant.
+  static InferredTypeBase create(
+      TypeRules rules, Expression expression, DartType type) {
+
+    // Specialized inference:
+    if (expression is Literal) {
+      return new InferredTypeLiteral(rules, expression, type);
+    }
+    if (expression is InstanceCreationExpression) {
+      return new InferredTypeAllocation(rules, expression, type);
+    }
+    return new InferredType(rules, expression, type);
+  }
+}
+
+// An infered type for a literal expression.
+class InferredTypeLiteral extends InferredTypeBase {
+  InferredTypeLiteral(TypeRules rules, Expression expression, DartType type)
+      : super._internal(rules, expression, type);
+}
+
+// An inferred type for a non-literal allocation site.
+class InferredTypeAllocation extends InferredTypeBase {
+  InferredTypeAllocation(TypeRules rules, Expression expression, DartType type)
+      : super._internal(rules, expression, type);
+}
+
 // TODO(vsm): Remove these.
 
 // A wrapped closure coerces the underlying type to the desired type.
 class ClosureWrapBase extends Conversion {
   FunctionType _wrappedType;
   Wrapper _wrapper;
 
   ClosureWrapBase._internal(
       TypeRules rules, Expression expression, this._wrapper, this._wrappedType)
       : super(rules, expression) {
@@ skipping 276 matching lines @@
   R visitRuntimeOperation(RuntimeOperation node) => visitNode(node);
 
   /// The catch-all for any kind of conversion
   R visitConversion(Conversion node) => visitNode(node);
 
   // Methods for conversion subtypes:
   R visitDownCast(DownCast node) => visitConversion(node);
   R visitClosureWrapBase(ClosureWrapBase node) => visitConversion(node);
   R visitClosureWrap(ClosureWrap node) => visitClosureWrapBase(node);
   R visitDynamicInvoke(DynamicInvoke node) => visitConversion(node);
+  R visitInferredTypeBase(InferredTypeBase node) => visitConversion(node);
 }
 
 /// Automatically infer list of types by scanning this library using mirrors.
 final List<Type> infoTypes = () {
   var allTypes = new Set();
   var baseTypes = new Set();
   var infoMirror = reflectClass(StaticInfo);
   var declarations = infoMirror.owner.declarations.values;
   for (var cls in declarations.where((d) => d is ClassMirror)) {
     if (cls.isSubtypeOf(infoMirror)) {
       allTypes.add(cls);
       baseTypes.add(cls.superclass);
     }
   }
   allTypes.removeAll(baseTypes);
   return new List<Type>.from(allTypes.map((mirror) => mirror.reflectedType))
     ..sort((t1, t2) => '$t1'.compareTo('$t2'));
 }();