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';
   }
 
-  bool get isNullable => true;
-
   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 {
   InternalSimpleTypesInferrer internal;
   Compiler compiler;
@@ skipping 514 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
+        // Parameters are being checked by the method, and we can
+        // therefore only trust their type after the checks.
+        || (compiler.enableTypeAssertions && !analyzedElement.isParameter())) {
+      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 || compiler.enableTypeAssertions)
+          && (element.isFunction()
+              || element.isGetter()
+              || element.isFactoryConstructor())) {
+        returnType = narrowType(
+            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()
+               || element.isVariable()))
+          // Parameters are being checked by the method, and we can
+          // therefore only trust their type after the checks.
+          || (compiler.enableTypeAssertions
+              && (element.isField() || element.isVariable()))) {
+        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 480 matching lines @@
       // to use dynamic. Fix that.
       return union.containsAll(compiler) ? dynamicType : union;
     }
   }
 
   TypeMask narrowType(TypeMask type,
                       DartType annotation,
                       {bool isNullable: true}) {
     if (annotation.isDynamic) return type;
     if (annotation.isMalformed) return type;
+    if (annotation.isVoid) return nullType;
     if (annotation.element == compiler.objectClass) return type;
     TypeMask otherType;
     if (annotation.kind == TypeKind.TYPEDEF
         || annotation.kind == TypeKind.FUNCTION) {
       otherType = functionType;
     } else if (annotation.kind == TypeKind.TYPE_VARIABLE) {
       return type;
     } else {
       assert(annotation.kind == TypeKind.INTERFACE);
       otherType = new TypeMask.nonNullSubtype(annotation);
@@ skipping 64 matching lines @@
 
   TypeMask use(Element local) {
     if (capturedAndBoxed.contains(local)) {
       return inferrer.typeOfElement(local);
     }
     return locals[local];
   }
 
   void update(Element local, TypeMask type) {
     assert(type != null);
+    if (inferrer.compiler.trustTypeAnnotations
+        || inferrer.compiler.enableTypeAssertions) {
+      type = inferrer.narrowType(type, local.computeType(inferrer.compiler));
+    }
     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;
@@ skipping 1080 matching lines @@
   }
 
   TypeMask visitParenthesizedExpression(ParenthesizedExpression node) {
     return visit(node.expression);
   }
 
   void internalError(String reason, {Node node}) {
     compiler.internalError(reason, node: node);
   }
 }