dart2js: Trust type annotations more often with --trust-type-annotation.

pkg/compiler/lib/src/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 /// A synthetic local variable only used with the SSA graph.
 ///
 /// For instance used for holding return value of function or the exception of a
 /// try-catch statement.
@@ skipping 988 matching lines @@
 
   CodegenRegistry get registry => work.registry;
 
   /// Returns the current source element.
   ///
   /// The returned element is a declaration element.
   // TODO(johnniwinther): Check that all usages of sourceElement agree on
   // implementation/declaration distinction.
   Element get sourceElement => sourceElementStack.last;
 
+  bool get _checkOrTrustTypes =>
+      compiler.enableTypeAssertions || compiler.trustTypeAnnotations;
+
   HBasicBlock addNewBlock() {
     HBasicBlock block = graph.addNewBlock();
     // If adding a new block during building of an expression, it is due to
     // conditional expressions or short-circuit logical operators.
     return block;
   }
 
   void open(HBasicBlock block) {
     block.open();
     current = block;
@@ skipping 457 matching lines @@
   HGraph buildCheckedSetter(VariableElement field) {
     openFunction(field, field.node);
     HInstruction thisInstruction = localsHandler.readThis();
     // Use dynamic type because the type computed by the inferrer is
     // narrowed to the type annotation.
     HInstruction parameter = new HParameterValue(field, backend.dynamicType);
     // Add the parameter as the last instruction of the entry block.
     // If the method is intercepted, we want the actual receiver
     // to be the first parameter.
     graph.entry.addBefore(graph.entry.last, parameter);
-    HInstruction value =
-        potentiallyCheckType(parameter, field.type);
+    HInstruction value = potentiallyCheckOrTrustType(parameter, field.type);
     add(new HFieldSet(field, thisInstruction, value));
     return closeFunction();
   }
 
   HGraph buildLazyInitializer(VariableElement variable) {
     ast.Node node = variable.node;
     openFunction(variable, node);
     assert(variable.initializer != null);
     visit(variable.initializer);
     HInstruction value = pop();
-    value = potentiallyCheckType(value, variable.type);
+    value = potentiallyCheckOrTrustType(value, variable.type);
     closeAndGotoExit(new HReturn(value));
     return closeFunction();
   }
 
   /**
    * Returns the constructor body associated with the given constructor or
    * creates a new constructor body, if none can be found.
    *
    * Returns [:null:] if the constructor does not have a body.
    */
@@ skipping 142 matching lines @@
      * [visitForIn].
      */
     return currentNode.asForIn() != null;
   }
 
   /**
    * In checked mode, generate type tests for the parameters of the inlined
    * function.
    */
   void potentiallyCheckInlinedParameterTypes(FunctionElement function) {
-    if (!compiler.enableTypeAssertions) return;
+    if (!_checkOrTrustTypes) return;
 
     FunctionSignature signature = function.functionSignature;
     signature.orderedForEachParameter((ParameterElement parameter) {
       HInstruction argument = localsHandler.readLocal(parameter);
-      potentiallyCheckType(argument, parameter.type);
+      potentiallyCheckOrTrustType(argument, parameter.type);
     });
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [constructors] must contain only implementation elements.
    */
   void inlineSuperOrRedirect(FunctionElement callee,
                              List<HInstruction> compiledArguments,
@@ skipping 290 matching lines @@
     classElement.forEachInstanceField(
         (ClassElement enclosingClass, VariableElement member) {
           HInstruction value = fieldValues[member];
           if (value == null) {
             // Uninitialized native fields are pre-initialized by the native
             // implementation.
             assert(isNativeUpgradeFactory);
           } else {
             fields.add(member);
             DartType type = localsHandler.substInContext(member.type);
-            constructorArguments.add(potentiallyCheckType(value, type));
+            constructorArguments.add(potentiallyCheckOrTrustType(value, type));
           }
         },
         includeSuperAndInjectedMembers: true);
 
     InterfaceType type = classElement.thisType;
     TypeMask ssaType =
         new TypeMask.nonNullExact(classElement.declaration, compiler.world);
     List<DartType> instantiatedTypes;
     addInlinedInstantiation(type);
     if (!currentInlinedInstantiations.isEmpty) {
@@ skipping 224 matching lines @@
           //     class A {
           //       A(String foo) = A.b;
           //       A(int foo) { print(foo); }
           //     }
           //     main() {
           //       new A(499);    // valid even in checked mode.
           //       new A("foo");  // invalid in checked mode.
           //
           // Only the final target is allowed to check for the argument types.
           newParameter =
-              potentiallyCheckType(newParameter, parameterElement.type);
+              potentiallyCheckOrTrustType(newParameter, parameterElement.type);
         }
         localsHandler.directLocals[parameterElement] = newParameter;
       });
 
       returnType = signature.type.returnType;
     } else {
       // Otherwise it is a lazy initializer which does not have parameters.
       assert(element is VariableElement);
     }
 
@@ skipping 56 matching lines @@
           null,
           new Selector.call(name, backend.jsHelperLibrary, 1),
           arguments);
 
       return new HTypeConversion(type, kind, original.instructionType, pop());
     } else {
       return original.convertType(compiler, type, kind);
     }
   }
 
-  HInstruction potentiallyBuildTypeHint(HInstruction original, DartType type) {
-    if (!compiler.trustTypeAnnotations || type == null) return original;
+  HInstruction _trustType(HInstruction original, DartType type) {
+    assert(compiler.trustTypeAnnotations);
+    assert(type != null);
     type = localsHandler.substInContext(type);
+    type = type.unalias(compiler);
+    if (type.isDynamic) return original;
     if (!type.isInterfaceType) return original;
-    TypeMask mask = new TypeMask.subtype(type.element, compiler.world);
-    var result = new HTypeKnown.pinned(mask, original);
-    return result;
+    // The type element is either a class or the void element.
+    Element element = type.element;
+    if (element == compiler.objectClass) return original;
+    TypeMask mask = new TypeMask.subtype(element, compiler.world);
+    return new HTypeKnown.pinned(mask, original);
   }
 
-  HInstruction potentiallyCheckType(HInstruction original, DartType type,
-      { int kind: HTypeConversion.CHECKED_MODE_CHECK }) {
-    if (!compiler.enableTypeAssertions) return original;
+  HInstruction _checkType(HInstruction original, DartType type, int kind) {
+    assert(compiler.enableTypeAssertions);
+    assert(type != null);
     type = localsHandler.substInContext(type);
     HInstruction other = buildTypeConversion(original, type, kind);
-    if (other != original) add(other);
     registry.registerIsCheck(type);
     return other;
   }
 
+  HInstruction potentiallyCheckOrTrustType(HInstruction original, DartType type,
+      { int kind: HTypeConversion.CHECKED_MODE_CHECK }) {
+    if (type == null) return original;
+    HInstruction checkedOrTrusted = original;
+    if (compiler.trustTypeAnnotations) {
+      checkedOrTrusted = _trustType(original, type);
+    } else if (compiler.enableTypeAssertions) {
+      checkedOrTrusted = _checkType(original, type, kind);
+    }
+    if (checkedOrTrusted == original) return original;
+    add(checkedOrTrusted);
+    return checkedOrTrusted;
+  }
+
   void assertIsSubtype(ast.Node node, DartType subtype, DartType supertype,
                        String message) {
     HInstruction subtypeInstruction =
         analyzeTypeArgument(localsHandler.substInContext(subtype));
     HInstruction supertypeInstruction =
         analyzeTypeArgument(localsHandler.substInContext(supertype));
     HInstruction messageInstruction =
         graph.addConstantString(new ast.DartString.literal(message), compiler);
     Element element = backend.getAssertIsSubtype();
     var inputs = <HInstruction>[subtypeInstruction, supertypeInstruction,
@@ skipping 23 matching lines @@
   HInstruction pop() {
     return stack.removeLast();
   }
 
   void dup() {
     stack.add(stack.last);
   }
 
   HInstruction popBoolified() {
     HInstruction value = pop();
-    if (compiler.enableTypeAssertions) {
-      return potentiallyCheckType(
+    if (_checkOrTrustTypes) {
+      return potentiallyCheckOrTrustType(
           value,
           compiler.boolClass.rawType,
           kind: HTypeConversion.BOOLEAN_CONVERSION_CHECK);
     }
     HInstruction result = new HBoolify(value, backend.boolType);
     add(result);
     return result;
   }
 
   HInstruction attachPosition(HInstruction target, ast.Node node) {
@@ skipping 806 matching lines @@
     if (location == null) {
       assert(send != null);
       location = send;
     }
     if (Elements.isStaticOrTopLevelField(element)) {
       if (element.isSetter) {
         pushInvokeStatic(location, element, <HInstruction>[value]);
         pop();
       } else {
         VariableElement field = element;
-        value =
-            potentiallyCheckType(value, field.type);
+        value = potentiallyCheckOrTrustType(value, field.type);
         addWithPosition(new HStaticStore(element, value), location);
       }
       stack.add(value);
     } else if (Elements.isErroneousElement(element)) {
       List<HInstruction> arguments =
           send == null ? const <HInstruction>[] : <HInstruction>[value];
       // An erroneous element indicates an unresolved static setter.
       generateThrowNoSuchMethod(location,
                                 noSuchMethodTargetSymbolString(element, 'set'),
                                 argumentValues: arguments);
     } else {
       stack.add(value);
       LocalElement local = element;
       // If the value does not already have a name, give it here.
       if (value.sourceElement == null) {
         value.sourceElement = local;
       }
-      HInstruction checked =
-          potentiallyCheckType(value, local.type);
-      if (!identical(checked, value)) {
+      HInstruction checkedOrTrusted =
+          potentiallyCheckOrTrustType(value, local.type);
+      if (!identical(checkedOrTrusted, value)) {
         pop();
-        stack.add(checked);
-      }
-      HInstruction trusted =
-          potentiallyBuildTypeHint(checked, local.type);
-      if (!identical(trusted, checked)) {
-        pop();
-        push(trusted);
+        stack.add(checkedOrTrusted);
       }
 
-      localsHandler.updateLocal(local, trusted);
+      localsHandler.updateLocal(local, checkedOrTrusted);
     }
   }
 
   HInstruction invokeInterceptor(HInstruction receiver) {
     HInterceptor interceptor = new HInterceptor(receiver, backend.nonNullType);
     add(interceptor);
     return interceptor;
   }
 
   HForeign createForeign(js.Template code,
@@ skipping 1065 matching lines @@
     // the 'new' is done.
     if (backend.classNeedsRti(compiler.listClass) &&
         (isFixedListConstructorCall || isGrowableListConstructorCall ||
          isJSArrayTypedConstructor)) {
       newInstance = handleListConstructor(type, send, pop());
       stack.add(newInstance);
     }
 
     // Finally, if we called a redirecting factory constructor, check the type.
     if (isRedirected) {
-      HInstruction checked = potentiallyCheckType(newInstance, type);
+      HInstruction checked = potentiallyCheckOrTrustType(newInstance, type);
       if (checked != newInstance) {
         pop();
         stack.add(checked);
       }
     }
   }
 
   void potentiallyAddTypeArguments(List<HInstruction> inputs, ClassElement cls,
                                    InterfaceType expectedType) {
     if (!backend.classNeedsRti(cls)) return;
@@ skipping 717 matching lines @@
     if (identical(node.beginToken.stringValue, 'native')) {
       native.handleSsaNative(this, node.expression);
       return;
     }
     HInstruction value;
     if (node.expression == null) {
       value = graph.addConstantNull(compiler);
     } else {
       visit(node.expression);
       value = pop();
-      value = potentiallyCheckType(value, returnType);
+      value = potentiallyCheckOrTrustType(value, returnType);
     }
 
     handleInTryStatement();
     emitReturn(value, node);
   }
 
   visitThrow(ast.Throw node) {
     visitThrowExpression(node.expression);
     if (isReachable) {
       handleInTryStatement();
@@ skipping 1513 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }