Implement checked mode in new compiler.

runtime/vm/flow_graph_builder.cc

 // 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.
 
 #include "vm/flow_graph_builder.h"
 
 #include "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
@@ skipping 188 matching lines @@
   Value* return_value = for_value.value();
   if (FLAG_enable_type_checks) {
     const RawFunction::Kind kind = owner()->parsed_function().function().kind();
     const bool is_implicit_getter =
         (kind == RawFunction::kImplicitGetter) ||
         (kind == RawFunction::kConstImplicitGetter);
     const bool is_static = owner()->parsed_function().function().is_static();
     // Implicit getters do not need a type check at return, unless they compute
     // the initial value of a static field.
     if (is_static || !is_implicit_getter) {
-      const AbstractType& type =
+      const AbstractType& dst_type =
           AbstractType::ZoneHandle(
               owner()->parsed_function().function().result_type());
+      const String& dst_name =
+          String::ZoneHandle(String::NewSymbol("function result"));
+      Value* type_arguments = NULL;
+      if (!dst_type.IsInstantiated()) {
+        type_arguments = BuildInstantiatorTypeArguments(
+            node->token_index(), for_value.temp_index());
+      }
       AssertAssignableComp* assert =
-          new AssertAssignableComp(return_value, type);
+          new AssertAssignableComp(node->id(),
+                                   node->value()->token_index(),
+                                   owner()->try_index(),
+                                   return_value,
+                                   type_arguments,
+                                   dst_type,
+                                   dst_name);
       AddInstruction(new BindInstr(temp_index(), assert));
       return_value = new TempVal(temp_index());
     }
   }
 
   intptr_t current_context_level = owner()->context_level();
   ASSERT(current_context_level >= 0);
   if (owner()->parsed_function().saved_context_var() != NULL) {
     // CTX on entry was saved, but not linked as context parent.
     BuildLoadContext(*owner()->parsed_function().saved_context_var(), 0);
@@ skipping 29 matching lines @@
 void EffectGraphVisitor::VisitTypeNode(TypeNode* node) { UNREACHABLE(); }
 
 
 // <Expression> :: Assignable { expr:     <Expression>
 //                              type:     AbstractType
 //                              dst_name: String }
 void EffectGraphVisitor::VisitAssignableNode(AssignableNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->expr()->Visit(&for_value);
   Append(for_value);
-  AssertAssignableComp* assert =
-      new AssertAssignableComp(for_value.value(), node->type());
-  ReturnComputation(assert);
+  Value* type_arguments = NULL;
+  if (!node->type().IsInstantiated()) {
+    type_arguments = BuildInstantiatorTypeArguments(
+        node->token_index(), for_value.temp_index());
+  }
+  AssertAssignableComp* assert_assignable =
+      new AssertAssignableComp(node->id(),
+                               node->token_index(),
+                               owner()->try_index(),
+                               for_value.value(),
+                               type_arguments,
+                               node->type(),
+                               node->dst_name());
+  ReturnComputation(assert_assignable);
 }
 
 
 // <Expression> :: BinaryOp { kind:  Token::Kind
 //                            left:  <Expression>
 //                            right: <Expression> }
 void EffectGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
@@ skipping 33 matching lines @@
 
 // Special handling for AND/OR.
 void ValueGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // Implement short-circuit logic: do not evaluate right if evaluation
     // of left is sufficient.
     // AND:  left ? right === true : false;
     // OR:   left ? true : right === true;
-    if (FLAG_enable_type_checks) {
-      Bailout("GenerateConditionTypeCheck in kAND/kOR");
-    }
     const Bool& bool_true = Bool::ZoneHandle(Bool::True());
     const Bool& bool_false = Bool::ZoneHandle(Bool::False());
 
     TestGraphVisitor for_test(owner(), temp_index());
     node->left()->Visit(&for_test);
+    if (FLAG_enable_type_checks) {
+      Bailout("GenerateConditionTypeCheck in kAND/kOR");
+    }
 
     ValueGraphVisitor for_right(owner(), temp_index());
     node->right()->Visit(&for_right);
+    if (FLAG_enable_type_checks) {
+      Bailout("GenerateConditionTypeCheck in kAND/kOR");
+    }
     StrictCompareComp* comp = new StrictCompareComp(Token::kEQ_STRICT,
         for_right.value(), new ConstantVal(bool_true));
     for_right.AddInstruction(new BindInstr(temp_index(), comp));
 
     if (node->kind() == Token::kAND) {
       ValueGraphVisitor for_false(owner(), temp_index());
       for_false.AddInstruction(
           new BindInstr(temp_index(), new ConstantVal(bool_false)));
       Join(for_test, for_right, for_false);
     } else {
@@ skipping 145 matching lines @@
   }
 
   ArgumentGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   Value* type_arguments = NULL;
   if (!type.IsInstantiated()) {
     type_arguments = BuildInstantiatorTypeArguments(
         node->token_index(), for_left_value.temp_index());
   }
-  InstanceOfComp* instance_of = new InstanceOfComp(
-      node->id(),
-      node->token_index(),
-      owner()->try_index(),
-      for_left_value.value(),
-      type_arguments,
-      node->right()->AsTypeNode()->type(),
-      (node->kind() == Token::kISNOT));
+  InstanceOfComp* instance_of =
+      new InstanceOfComp(node->id(),
+                         node->token_index(),
+                         owner()->try_index(),
+                         for_left_value.value(),
+                         type_arguments,
+                         node->right()->AsTypeNode()->type(),
+                         (node->kind() == Token::kISNOT));
   ReturnComputation(instance_of);
 }
 
 
 // <Expression> :: Comparison { kind:  Token::Kind
 //                              left:  <Expression>
 //                              right: <Expression> }
 void EffectGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
   if (Token::IsInstanceofOperator(node->kind())) {
     BuildInstanceOf(node);
@@ skipping 314 matching lines @@
       node->store_id(), node->token_index(), owner()->try_index(),
       store_name, arguments, Array::ZoneHandle(), 1);
   AddInstruction(new DoInstr(store));
   ReturnValue(new TempVal(AllocateTempIndex()));
 }
 
 
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   TestGraphVisitor for_test(owner(), temp_index());
   node->condition()->Visit(&for_test);
+  if (FLAG_enable_type_checks) {
+    Bailout("GenerateConditionTypeCheck in conditional expr");
+  }
 
   // Translate the subexpressions for their effects.
   EffectGraphVisitor for_true(owner(), temp_index());
   node->true_expr()->Visit(&for_true);
   EffectGraphVisitor for_false(owner(), temp_index());
   node->false_expr()->Visit(&for_false);
 
   Join(for_test, for_true, for_false);
 }
 
 
 void ValueGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   TestGraphVisitor for_test(owner(), temp_index());
   node->condition()->Visit(&for_test);
+  if (FLAG_enable_type_checks) {
+    Bailout("GenerateConditionTypeCheck in conditional expr");
+  }
 
   // Ensure that the value of the true/false subexpressions are named with
   // the same temporary name.
   ValueGraphVisitor for_true(owner(), temp_index());
   node->true_expr()->Visit(&for_true);
   ASSERT(for_true.is_open());
   if (for_true.value()->IsTemp()) {
     ASSERT(for_true.value()->AsTemp()->index() == temp_index());
   } else {
     for_true.AddInstruction(new BindInstr(temp_index(), for_true.value()));
@@ skipping 12 matching lines @@
   ReturnValue(new TempVal(AllocateTempIndex()));
 }
 
 
 // <Statement> ::= If { condition: <Expression>
 //                      true_branch: <Sequence>
 //                      false_branch: <Sequence> }
 void EffectGraphVisitor::VisitIfNode(IfNode* node) {
   TestGraphVisitor for_test(owner(), temp_index());
   node->condition()->Visit(&for_test);
+  if (FLAG_enable_type_checks) {
+    Bailout("GenerateConditionTypeCheck in if");
+  }
 
   EffectGraphVisitor for_true(owner(), temp_index());
   EffectGraphVisitor for_false(owner(), temp_index());
 
   node->true_branch()->Visit(&for_true);
   // The for_false graph fragment will be empty (default graph fragment) if
   // we do not call Visit.
   if (node->false_branch() != NULL) node->false_branch()->Visit(&for_false);
   Join(for_test, for_true, for_false);
 }
@@ skipping 150 matching lines @@
 // c) [ test ] -> (body-entry-target, loop-exit-target)
 // d) body-entry-target
 // e) [ body ] -> (loop-join)
 // f) loop-exit-target
 // g) break-join (optional)
 void EffectGraphVisitor::VisitWhileNode(WhileNode* node) {
   TestGraphVisitor for_test(owner(), temp_index());
   node->condition()->Visit(&for_test);
   ASSERT(!for_test.is_empty());  // Language spec.
 
+  if (FLAG_enable_type_checks) {
+    Bailout("GenerateConditionTypeCheck in while");
+  }
+
   EffectGraphVisitor for_body(owner(), temp_index());
   node->body()->Visit(&for_body);
 
   // Labels are set after body traversal.
   SourceLabel* lbl = node->label();
   ASSERT(lbl != NULL);
   if (lbl->join_for_continue() != NULL) {
     AddInstruction(lbl->join_for_continue());
   }
   TieLoop(for_test, for_body);
@@ skipping 13 matching lines @@
 // g) break-join
 void EffectGraphVisitor::VisitDoWhileNode(DoWhileNode* node) {
   // Traverse body first in order to generate continue and break labels.
   EffectGraphVisitor for_body(owner(), temp_index());
   node->body()->Visit(&for_body);
 
   TestGraphVisitor for_test(owner(), temp_index());
   node->condition()->Visit(&for_test);
   ASSERT(is_open());
 
+  if (FLAG_enable_type_checks) {
+    Bailout("GenerateConditionTypeCheck in do while");
+  }
+
   // Tie do-while loop (test is after the body).
   JoinEntryInstr* body_entry_join = new JoinEntryInstr();
   AddInstruction(body_entry_join);
   body_entry_join->SetSuccessor(for_body.entry());
   Instruction* body_exit =
       for_body.is_empty() ? body_entry_join : for_body.exit();
 
   if (for_body.is_open() || (node->label()->join_for_continue() != NULL)) {
     BlockEntryInstr* test_entry = NULL;
     if (node->label()->join_for_continue() == NULL) {
@@ skipping 85 matching lines @@
       CloseFragment();
     } else {
       // Control flow of ForLoop continues into join_for_break.
       exit_ = node->label()->join_for_break();
     }
   } else {
     TargetEntryInstr* loop_exit = new TargetEntryInstr();
     TestGraphVisitor for_test(owner(), temp_index());
     node->condition()->Visit(&for_test);
     Append(for_test);
+    if (FLAG_enable_type_checks) {
+      Bailout("GenerateConditionTypeCheck in for");
+    }
     *for_test.true_successor_address() = body_entry;
     *for_test.false_successor_address() = loop_exit;
     if (node->label()->join_for_break() == NULL) {
       exit_ = loop_exit;
     } else {
       loop_exit->SetSuccessor(node->label()->join_for_break());
       exit_ = node->label()->join_for_break();
     }
   }
 }
@@ skipping 503 matching lines @@
 
 // <Expression> ::= StoreLocal { local: LocalVariable
 //                               value: <Expression> }
 void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
 
   Value* value = for_value.value();
   if (FLAG_enable_type_checks) {
-    AssertAssignableComp* assert =
-        new AssertAssignableComp(value, node->local().type());
-    AddInstruction(new BindInstr(temp_index(), assert));
+    Value* type_arguments = NULL;
+    if (!node->local().type().IsInstantiated()) {
+      type_arguments = BuildInstantiatorTypeArguments(
+          node->token_index(), for_value.temp_index());
+    }
+    AssertAssignableComp* assert_assignable =
+        new AssertAssignableComp(node->id(),
+                                 node->local().token_index(),
+                                 owner()->try_index(),
+                                 value,
+                                 type_arguments,
+                                 node->local().type(),
+                                 node->local().name());
+    AddInstruction(new BindInstr(temp_index(), assert_assignable));
     value = new TempVal(temp_index());
   }
 
   StoreLocalComp* store =
       new StoreLocalComp(node->local(), value, owner()->context_level());
   ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadInstanceFieldNode(
@@ skipping 11 matching lines @@
     StoreInstanceFieldNode* node) {
   ValueGraphVisitor for_instance(owner(), temp_index());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
   ValueGraphVisitor for_value(owner(), for_instance.temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     const AbstractType& type = AbstractType::ZoneHandle(node->field().type());
-    AssertAssignableComp* assert = new AssertAssignableComp(store_value, type);
-    AddInstruction(new BindInstr(temp_index(), assert));
-    store_value = new TempVal(temp_index());
+    Value* type_arguments = NULL;
+    if (!type.IsInstantiated()) {
+      type_arguments = BuildInstantiatorTypeArguments(
+          node->token_index(), for_value.temp_index());
+    }
+    AssertAssignableComp* assert_assignable =
+        new AssertAssignableComp(node->id(),
+                                 node->value()->token_index(),
+                                 owner()->try_index(),
+                                 store_value,
+                                 type_arguments,
+                                 type,
+                                 String::ZoneHandle(node->field().name()));
+    AddInstruction(new BindInstr(temp_index() + 1, assert_assignable));
+    store_value = new TempVal(temp_index() + 1);
   }
   StoreInstanceFieldComp* store =
       new StoreInstanceFieldComp(node, for_instance.value(), store_value);
   ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadStaticFieldNode(LoadStaticFieldNode* node) {
   LoadStaticFieldComp* load = new LoadStaticFieldComp(node->field());
   ReturnComputation(load);
 }
 
 
 void EffectGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     const AbstractType& type = AbstractType::ZoneHandle(node->field().type());
-    AssertAssignableComp* assert = new AssertAssignableComp(store_value, type);
-    AddInstruction(new BindInstr(temp_index(), assert));
+    Value* type_arguments = NULL;
+    if (!type.IsInstantiated()) {
+      type_arguments = BuildInstantiatorTypeArguments(
+          node->token_index(), for_value.temp_index());
+    }
+    AssertAssignableComp* assert_assignable =
+        new AssertAssignableComp(node->id(),
+                                 node->field().token_index(),
+                                 owner()->try_index(),
+                                 store_value,
+                                 type_arguments,
+                                 type,
+                                 String::ZoneHandle(node->field().name()));
+    AddInstruction(new BindInstr(temp_index(), assert_assignable));
     store_value = new TempVal(temp_index());
   }
   StoreStaticFieldComp* store =
       new StoreStaticFieldComp(node->field(), store_value);
   ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadIndexedNode(LoadIndexedNode* node) {
   ArgumentGraphVisitor for_array(owner(), temp_index());
@@ skipping 131 matching lines @@
               new ConstantVal(Object::ZoneHandle()),
               owner()->context_level());
           AddInstruction(new DoInstr(clear_local));
         }
       }
     }
   }
 
   if (FLAG_enable_type_checks &&
       (node == owner()->parsed_function().node_sequence())) {
-    Bailout("VisitSequenceNode GenerateArgumentTypeChecks()");
+    const int num_params =
+        owner()->parsed_function().function().NumberOfParameters();
+    for (int pos = 0; pos < num_params; pos++) {
+      const LocalVariable& parameter = *scope->VariableAt(pos);
+      ASSERT(parameter.owner() == scope);
+      LoadLocalComp* load = new LoadLocalComp(parameter,
+                                              owner()->context_level());
+      AddInstruction(new BindInstr(temp_index(), load));
+      TempVal* argument_value = new TempVal(temp_index());
+      Value* type_arguments = NULL;
+      if (!parameter.type().IsInstantiated()) {
+        type_arguments = BuildInstantiatorTypeArguments(
+            node->token_index(), temp_index() + 1);
+      }
+      AssertAssignableComp* assert_assignable =
+          new AssertAssignableComp(node->id(),
+                                   parameter.token_index(),
+                                   owner()->try_index(),
+                                   argument_value,
+                                   type_arguments,
+                                   parameter.type(),
+                                   parameter.name());
+      AddInstruction(new DoInstr(assert_assignable));
+    }
   }
 
   intptr_t i = 0;
   while (is_open() && (i < node->length())) {
     EffectGraphVisitor for_effect(owner(), temp_index());
     node->NodeAt(i++)->Visit(&for_effect);
     Append(for_effect);
     if (!is_open()) {
       // E.g., because of a JumpNode.
       break;
@@ skipping 214 matching lines @@
 
 
 void FlowGraphPrinter::VisitConstant(ConstantVal* val) {
   OS::Print("#%s", val->value().ToCString());
 }
 
 
 void FlowGraphPrinter::VisitAssertAssignable(AssertAssignableComp* comp) {
   OS::Print("AssertAssignable(");
   comp->value()->Accept(this);
-  OS::Print(", %s)", comp->type().ToCString());
+  OS::Print(", %s, '%s'",
+            comp->dst_type().ToCString(),
+            comp->dst_name().ToCString());
+  if (comp->type_arguments() != NULL) {
+    OS::Print(" (type-arg:");
+    comp->type_arguments()->Accept(this);
+  }
+  OS::Print(")");
+}
+
+
+void FlowGraphPrinter::VisitAssertBoolean(AssertBooleanComp* comp) {
+  OS::Print("AssertBoolean(");
+  comp->value()->Accept(this);
+  OS::Print(")");
 }
 
 
 void FlowGraphPrinter::VisitCurrentContext(CurrentContextComp* comp) {
   OS::Print("CurrentContext");
 }
 
 
 void FlowGraphPrinter::VisitClosureCall(ClosureCallComp* comp) {
   OS::Print("ClosureCall(");
@@ skipping 18 matching lines @@
 
 void FlowGraphPrinter::VisitStrictCompare(StrictCompareComp* comp) {
   OS::Print("StrictCompare(%s, ", Token::Str(comp->kind()));
   comp->left()->Accept(this);
   OS::Print(", ");
   comp->right()->Accept(this);
   OS::Print(")");
 }
 
 
-
 void FlowGraphPrinter::VisitStaticCall(StaticCallComp* comp) {
   OS::Print("StaticCall(%s",
             String::Handle(comp->function().name()).ToCString());
   for (intptr_t i = 0; i < comp->ArgumentCount(); ++i) {
     OS::Print(", ");
     comp->ArgumentAt(i)->Accept(this);
   }
   OS::Print(")");
 }
 
@@ skipping 19 matching lines @@
 void FlowGraphPrinter::VisitLoadInstanceField(LoadInstanceFieldComp* comp) {
   OS::Print("LoadInstanceField(%s, ",
       String::Handle(comp->field().name()).ToCString());
   comp->instance()->Accept(this);
   OS::Print(")");
 }
 
 
 void FlowGraphPrinter::VisitStoreInstanceField(StoreInstanceFieldComp* comp) {
   OS::Print("StoreInstanceField(%s, ",
-      String::Handle(comp->field().name()).ToCString());
+            String::Handle(comp->field().name()).ToCString());
   comp->instance()->Accept(this);
   OS::Print(", ");
   comp->value()->Accept(this);
   OS::Print(")");
 }
 
 
 void FlowGraphPrinter::VisitLoadStaticField(LoadStaticFieldComp* comp) {
   OS::Print("LoadStaticField(%s)",
-      String::Handle(comp->field().name()).ToCString());
+            String::Handle(comp->field().name()).ToCString());
 }
 
 
 void FlowGraphPrinter::VisitStoreStaticField(StoreStaticFieldComp* comp) {
   OS::Print("StoreStaticField(%s, ",
-      String::Handle(comp->field().name()).ToCString());
+            String::Handle(comp->field().name()).ToCString());
   comp->value()->Accept(this);
   OS::Print(")");
 }
 
 
 void FlowGraphPrinter::VisitStoreIndexed(StoreIndexedComp* comp) {
   OS::Print("StoreIndexed(");
   comp->array()->Accept(this);
   OS::Print(", ");
   comp->index()->Accept(this);
@@ skipping 21 matching lines @@
 
 void FlowGraphPrinter::VisitBooleanNegate(BooleanNegateComp* comp) {
   OS::Print("! ");
   comp->value()->Accept(this);
 }
 
 
 void FlowGraphPrinter::VisitInstanceOf(InstanceOfComp* comp) {
   comp->value()->Accept(this);
   OS::Print(" %s %s",
-      comp->negate_result() ? "ISNOT" : "IS",
-      String::Handle(comp->type().Name()).ToCString());
+            comp->negate_result() ? "ISNOT" : "IS",
+            String::Handle(comp->type().Name()).ToCString());
   if (comp->type_arguments() != NULL) {
     OS::Print(" (type-arg:");
     comp->type_arguments()->Accept(this);
-    OS::Print(")");
   }
+  OS::Print(")");
 }
 
 
 void FlowGraphPrinter::VisitAllocateObject(AllocateObjectComp* comp) {
   OS::Print("AllocateObject(%s",
-      Class::Handle(comp->constructor().owner()).ToCString());
+            Class::Handle(comp->constructor().owner()).ToCString());
   for (intptr_t i = 0; i < comp->arguments().length(); i++) {
     OS::Print(", ");
     comp->arguments()[i]->Accept(this);
   }
   OS::Print(")");
 }
 
 
 void FlowGraphPrinter::VisitCreateArray(CreateArrayComp* comp) {
   OS::Print("CreateArray(");
@@ skipping 61 matching lines @@
 
 
 void FlowGraphPrinter::VisitCloneContext(CloneContextComp* comp) {
   OS::Print("CloneContext(");
   comp->context_value()->Accept(this);
   OS::Print(")");
 }
 
 
 void FlowGraphPrinter::VisitCatchEntry(CatchEntryComp* comp) {
-  OS::Print("CatchEntry(%s, %s)", comp->exception_var().name().ToCString(),
-                                  comp->stacktrace_var().name().ToCString());
+  OS::Print("CatchEntry(%s, %s)",
+            comp->exception_var().name().ToCString(),
+            comp->stacktrace_var().name().ToCString());
 }
 
 
 void FlowGraphPrinter::VisitStoreContext(StoreContextComp* comp) {
   OS::Print("StoreContext(");
   comp->value()->Accept(this);
   OS::Print(")");
 }
 
 
@@ skipping 200 matching lines @@
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart