dart2js cps: Support --trust-primitives and --trust-type-annotations.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.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 dart2js.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../common.dart';
 import '../common/names.dart' show
@@ skipping 35 matching lines @@
     NativeBehavior;
 
 // TODO(karlklose): remove.
 import '../js/js.dart' as js show js, Template, Expression, Name;
 import '../ssa/ssa.dart' show TypeMaskFactory;
 import '../util/util.dart';
 
 import 'package:js_runtime/shared/embedded_names.dart'
     show JsBuiltin, JsGetName;
 import '../constants/values.dart';
+import 'type_mask_system.dart' show
+    TypeMaskSystem;
 
 typedef void IrBuilderCallback(Element element, ir.FunctionDefinition irNode);
 
 /// This task provides the interface to build IR nodes from [ast.Node]s, which
 /// is used from the [CpsFunctionCompiler] to generate code.
 ///
 /// This class is mainly there to correctly measure how long building the IR
 /// takes.
 class IrBuilderTask extends CompilerTask {
   final SourceInformationStrategy sourceInformationStrategy;
 
   String bailoutMessage = null;
 
   /// If not null, this function will be called with for each
   /// [ir.FunctionDefinition] node that has been built.
   IrBuilderCallback builderCallback;
 
   IrBuilderTask(Compiler compiler, this.sourceInformationStrategy,
       [this.builderCallback])
       : super(compiler);
 
   String get name => 'CPS builder';
 
-  ir.FunctionDefinition buildNode(AstElement element) {
+  ir.FunctionDefinition buildNode(AstElement element,
+                                  TypeMaskSystem typeMaskSystem) {
     return measure(() {
       bailoutMessage = null;
 
       TreeElements elementsMapping = element.resolvedAst.elements;
       element = element.implementation;
       return reporter.withCurrentElement(element, () {
         SourceInformationBuilder sourceInformationBuilder =
             sourceInformationStrategy.createBuilderForContext(element);
 
         IrBuilderVisitor builder =
             new JsIrBuilderVisitor(
-                elementsMapping, compiler, sourceInformationBuilder);
+                elementsMapping, compiler, sourceInformationBuilder,
+                typeMaskSystem);
         ir.FunctionDefinition irNode = builder.buildExecutable(element);
         if (irNode == null) {
           bailoutMessage = builder.bailoutMessage;
         } else if (builderCallback != null) {
           builderCallback(element, irNode);
         }
         return irNode;
       });
     });
   }
@@ skipping 18 matching lines @@
          BaseImplementationOfDynamicsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfConstantsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfNewMixin<ir.Primitive, dynamic>,
          BaseImplementationOfCompoundsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfSetIfNullsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfIndexCompoundsMixin<ir.Primitive, dynamic>
     implements SemanticSendVisitor<ir.Primitive, dynamic> {
   final TreeElements elements;
   final Compiler compiler;
   final SourceInformationBuilder sourceInformationBuilder;
+  final TypeMaskSystem typeMaskSystem;
 
   /// A map from try statements in the source to analysis information about
   /// them.
   ///
   /// The analysis information includes the set of variables that must be
   /// copied into [ir.MutableVariable]s on entry to the try and copied out on
   /// exit.
   Map<ast.Node, TryStatementInfo> tryStatements = null;
 
   // In SSA terms, join-point continuation parameters are the phis and the
@@ skipping 10 matching lines @@
   //
   // Each nested visitor maintains a list that maps indexes of variables
   // assigned in the delimited subexpression to their reaching definition ---
   // that is, the definition in effect at the hole in 'current'.  These are
   // used to determine if a join-point continuation needs to be passed
   // arguments, and what the arguments are.
 
   /// Construct a top-level visitor.
   IrBuilderVisitor(this.elements,
                    this.compiler,
-                   this.sourceInformationBuilder);
+                   this.sourceInformationBuilder,
+                   this.typeMaskSystem);
 
   DiagnosticReporter get reporter => compiler.reporter;
 
   String bailoutMessage = null;
 
   @override
   ir.Primitive apply(ast.Node node, _) => node.accept(this);
 
   @override
   SemanticSendVisitor get sendVisitor => this;
@@ skipping 231 matching lines @@
         variableSelector: selector,
         variableMask: elements.getTypeMask(identifier),
         currentMask: elements.getCurrentTypeMask(node),
         moveNextMask: elements.getMoveNextTypeMask(node),
         iteratorMask: elements.getIteratorTypeMask(node),
         buildBody: subbuild(node.body),
         target: elements.getTargetDefinition(node),
         closureScope: getClosureScopeForNode(node));
   }
 
+  /// If compiling with trusted type annotations, assumes that [value] is
+  /// now known to be `null` or an instance of [type].
+  ///
+  /// This is also where we should add type checks in checked mode, but this
+  /// is not supported yet.
+  ir.Primitive checkType(ir.Primitive value, DartType dartType) {
+    if (!compiler.trustTypeAnnotations) return value;
+    TypeMask type = typeMaskSystem.subtypesOf(dartType).nullable();
+    return irBuilder.buildRefinement(value, type);
+  }
+
+  ir.Primitive checkTypeVsElement(ir.Primitive value, TypedElement element) {
+    return checkType(value, element.type);
+  }
+
   ir.Primitive visitVariableDefinitions(ast.VariableDefinitions node) {
     assert(irBuilder.isOpen);
     for (ast.Node definition in node.definitions.nodes) {
       Element element = elements[definition];
       ir.Primitive initialValue;
       // Definitions are either SendSets if there is an initializer, or
       // Identifiers if there is no initializer.
       if (definition is ast.SendSet) {
         assert(!definition.arguments.isEmpty);
         assert(definition.arguments.tail.isEmpty);
         initialValue = visit(definition.arguments.head);
+        initialValue = checkTypeVsElement(initialValue, element);
       } else {
         assert(definition is ast.Identifier);
       }
       irBuilder.declareLocalVariable(element, initialValue: initialValue);
     }
     return null;
   }
 
   static final RegExp nativeRedirectionRegExp =
       new RegExp(r'^[a-zA-Z][a-zA-Z_$0-9]*$');
@@ skipping 962 matching lines @@
             elements.getTypeMask(node),
             visit(rhs))));
   }
 
   @override
   ir.Primitive handleLocalSet(
       ast.SendSet node,
       LocalElement element,
       ast.Node rhs,
       _) {
-    return irBuilder.buildLocalVariableSet(element, visit(rhs));
+    ir.Primitive value = visit(rhs);
+    value = checkTypeVsElement(value, element);
+    return irBuilder.buildLocalVariableSet(element, value);
   }
 
   @override
   ir.Primitive handleStaticFieldSet(
       ast.SendSet node,
       FieldElement field,
       ast.Node rhs,
       _) {
     return irBuilder.buildStaticFieldSet(field, visit(rhs));
   }
@@ skipping 1107 matching lines @@
   JavaScriptBackend get backend => compiler.backend;
 
   /// Result of closure conversion for the current body of code.
   ///
   /// Will be initialized upon entering the body of a function.
   /// It is computed by the [ClosureTranslator].
   ClosureClassMap closureClassMap;
 
   JsIrBuilderVisitor(TreeElements elements,
                      Compiler compiler,
-                     SourceInformationBuilder sourceInformationBuilder)
-      : super(elements, compiler, sourceInformationBuilder);
+                     SourceInformationBuilder sourceInformationBuilder,
+                     TypeMaskSystem typeMaskSystem)
+      : super(elements, compiler, sourceInformationBuilder, typeMaskSystem);
 
 
   /// Builds the IR for creating an instance of the closure class corresponding
   /// to the given nested function.
   ClosureClassElement makeSubFunction(ast.FunctionExpression node) {
     ClosureClassMap innerMap =
         compiler.closureToClassMapper.getMappingForNestedFunction(node);
     ClosureClassElement closureClass = innerMap.closureClassElement;
     return closureClass;
   }
@@ skipping 132 matching lines @@
   }
 
   /// Make a visitor suitable for translating ASTs taken from [context].
   ///
   /// Every visitor can only be applied to nodes in one context, because
   /// the [elements] field is specific to that context.
   JsIrBuilderVisitor makeVisitorForContext(AstElement context) {
     return new JsIrBuilderVisitor(
         context.resolvedAst.elements,
         compiler,
-        sourceInformationBuilder.forContext(context));
+        sourceInformationBuilder.forContext(context),
+        typeMaskSystem);
   }
 
   /// Builds the IR for an [expression] taken from a different [context].
   ///
   /// Such expressions need to be compiled with a different [sourceFile] and
   /// [elements] mapping.
   ir.Primitive inlineExpression(AstElement context, ast.Expression expression) {
     JsIrBuilderVisitor visitor = makeVisitorForContext(context);
     return visitor.withBuilder(irBuilder, () => visitor.visit(expression));
   }
@@ skipping 878 matching lines @@
     if (compiler.backend.isForeign(function)) {
       return handleForeignCode(node, function, argumentList, callStructure);
     } else {
       return irBuilder.buildStaticFunctionInvocation(function, callStructure,
           translateStaticArguments(argumentList, function, callStructure),
           sourceInformation:
               sourceInformationBuilder.buildCall(node, node.selector));
     }
   }
 }