Add a new flag to dart2js: --trust-type-annotations and implement it in the types inferrer.

sdk/lib/_internal/compiler/implementation/types/simple_types_inferrer.dart

 // Copyright (c) 2013, 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 simple_types_inferrer;
 
 import 'dart:collection' show Queue, LinkedHashSet;
 
 import '../closure.dart' show ClosureClassMap, ClosureScope;
 import '../dart_types.dart' show DartType, FunctionType, TypeKind;
@@ skipping 95 matching lines @@
   SentinelTypeMask(this.name) : super(null, 0, false);
 
   bool operator==(other) {
     return identical(this, other);
   }
 
   TypeMask nullable() {
     throw 'Unsupported operation';
   }
 
+  TypeMask intersection(TypeMask other, Compiler compiler) {
+    return other;
+  }
+
   bool get isNullable => true;
 
   String toString() => '$name sentinel type mask';
 }
 
 final OPTIMISTIC = 0;
 final RETRY = 1;
 final PESSIMISTIC = 2;
 
 class SimpleTypesInferrer extends TypesInferrer {
@@ skipping 516 matching lines @@
   bool isNativeElement(Element element) {
     if (element.isNative()) return true;
     return element.isMember()
         && element.getEnclosingClass().isNative()
         && element.isField();
   }
 
   bool internalRecordType(Element analyzedElement,
                           TypeMask newType,
                           Map<Element, TypeMask> types) {
+    if (compiler.trustTypeAnnotations) {
+      var annotation = analyzedElement.computeType(compiler);
+      if (types == returnTypeOf) {
+        assert(annotation is FunctionType);
+        annotation = annotation.returnType;
+      }
+      newType = narrowType(newType, annotation);
+    }
+
     // Fields and native methods of native classes are handled
     // specially when querying for their type or return type.
     if (isNativeElement(analyzedElement)) return false;
     assert(newType != null);
     TypeMask existing = types[analyzedElement];
     types[analyzedElement] = newType;
     // If the return type is useful, say it has changed.
     return existing != newType
         && !isDynamicType(newType)
         && newType != nullType;
@@ skipping 15 matching lines @@
         var elementType = element.computeType(compiler);
         if (elementType.kind != TypeKind.FUNCTION) {
           return dynamicType;
         }
         return typeOfNativeBehavior(
             native.NativeBehavior.ofMethod(element, compiler));
       });
     }
     TypeMask returnType = returnTypeOf[element];
     if (returnType == null) {
-      return dynamicType;
+      if (compiler.trustTypeAnnotations
+          && (element.isFunction()
+              || element.isGetter()
+              || element.isFactoryConstructor())) {
+        returnType = narrowType(

[kasperl, 2013/05/16 13:17:20]

Couldn't you do the narrowing when you record? (like you do in
internalRecordType)

[ngeoffray, 2013/05/17 14:34:25]

This is in case the element has not been analyzed yet. We just return the type
annotation.

+            dynamicType, element.computeType(compiler).returnType);
+      } else {
+        returnType = dynamicType;
+      }
     }
     assert(returnType != null);
     return returnType;
   }
 
   TypeMask typeOfNativeBehavior(native.NativeBehavior nativeBehavior) {
     if (nativeBehavior == null) return dynamicType;
     List typesReturned = nativeBehavior.typesReturned;
     if (typesReturned.isEmpty) return dynamicType;
     TypeMask returnType;
@@ skipping 44 matching lines @@
     element = element.implementation;
     if (isNativeElement(element) && element.isField()) {
       var type = typeOf.putIfAbsent(element, () {
         return new TypeMask.subtype(element.computeType(compiler).asRaw());
       });
       assert(type != null);
       return type;
     }
     TypeMask type = typeOf[element];
     if (type == null) {
-      return dynamicType;
+      if (compiler.trustTypeAnnotations
+          && (element.isField()
+              || element.isParameter())) {
+        type = narrowType(dynamicType, element.computeType(compiler));
+      } else {
+        type = dynamicType;
+      }
     }
     assert(type != null);
     return type;
   }
 
   /**
    * Returns the union of the types of all elements that match
    * the called [selector].
    */
   TypeMask typeOfSelector(Selector selector) {
@@ skipping 476 matching lines @@
       return secondType;
     } else if (isDynamicType(firstType)) {
       return firstType;
     } else {
       TypeMask union = firstType.union(secondType, compiler);
       // TODO(kasperl): If the union isn't nullable it seems wasteful
       // to use dynamic. Fix that.
       return union.containsAll(compiler) ? dynamicType : union;
     }
   }
+
+  TypeMask narrowType(TypeMask type, DartType annotation) {
+    if (annotation.isDynamic) return type;
+    TypeMask otherType;
+    if (annotation.kind == TypeKind.TYPEDEF
+        || annotation.kind == TypeKind.FUNCTION) {
+      otherType = functionType.nullable();
+    } else if (annotation.kind != TypeKind.INTERFACE) {
+      return type;
+    } else {
+      otherType = new TypeMask.subtype(annotation);
+    }
+    return type.intersection(otherType, compiler);
+  }
 }
 
 /**
  * Placeholder for inferred arguments types on sends.
  */
 class ArgumentsTypes {
   final List<TypeMask> positional;
   final Map<SourceString, TypeMask> named;
   ArgumentsTypes(this.positional, named)
     : this.named = (named == null) ? new Map<SourceString, TypeMask>() : named;
@@ skipping 59 matching lines @@
     assert(type != null);
     if (capturedAndBoxed.contains(local) || inTryBlock) {
       // If a local is captured and boxed, or is set in a try block,
       // we compute the LUB of its assignments.
       //
       // We don't know if an assignment in a try block
       // will be executed, so all assigments in that block are
       // potential types after we have left it.
       type = inferrer.computeLUB(locals[local], type);
     }
     locals[local] = type;

[kasperl, 2013/05/16 13:17:20]

Shouldn't this use narrowing as well?

[ngeoffray, 2013/05/17 14:34:25]

Done.

   }
 
   void setCapturedAndBoxed(Element local) {
     capturedAndBoxed.add(local);
   }
 
   /**
    * Merge handlers [first] and [second] into [:this:] and returns
    * whether the merge changed one of the variables types in [first].
    */
@@ skipping 682 matching lines @@
       return inferrer.boolType;
     } else if (const SourceString("!") == op.source) {
       node.visitChildren(this);
       return inferrer.boolType;
     } else if (const SourceString("is") == op.source) {
       node.visitChildren(this);
       return inferrer.boolType;
     } else if (const SourceString("as") == op.source) {
       TypeMask receiverType = visit(node.receiver);
       DartType type = elements.getType(node.arguments.head);
-      if (type.isDynamic) return receiverType;
-      TypeMask asType = type.kind == TypeKind.TYPEDEF
-          ? inferrer.functionType.nullable()
-          : new TypeMask.subtype(type);
-      // TODO(ngeoffray): Remove when inferrer.dynamicType is a proper
-      // TypeMask.
-      if (inferrer.isDynamicType(receiverType)) return asType;
-      return receiverType.intersection(asType, compiler);
+      return inferrer.narrowType(receiverType, type);
     } else if (node.isParameterCheck) {
       node.visitChildren(this);
       return inferrer.boolType;
     } else if (node.argumentsNode is Prefix) {
       // Unary operator.
       return visitDynamicSend(node);
     } else if (const SourceString('===') == op.source
                || const SourceString('!==') == op.source) {
       node.visitChildren(this);
       return inferrer.boolType;
@@ skipping 306 matching lines @@
   }
 
   TypeMask visitParenthesizedExpression(ParenthesizedExpression node) {
     return visit(node.expression);
   }
 
   void internalError(String reason, {Node node}) {
     compiler.internalError(reason, node: node);
   }
 }