VM: [Kernel] Partial support for checked mode.

runtime/vm/kernel_to_il.cc

 // Copyright (c) 2016, 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 <map>
 #include <set>
 #include <string>
 
 #include "vm/kernel_to_il.h"
 
@@ skipping 1752 matching lines @@
     const Object& result =
         RunFunction(func, interpolate_arg, Array::null_array());
     result_ = H.Canonicalize(dart::String::Cast(result));
   }
 }
 
 
 void ConstantEvaluator::VisitConditionalExpression(
     ConditionalExpression* node) {
   EvaluateExpression(node->condition());
-  if (Bool::Cast(result_).value()) {
+  if (result_.raw() == Bool::True().raw()) {
     EvaluateExpression(node->then());
   } else {
+    MaybeCheckBool();
     EvaluateExpression(node->otherwise());
   }
 }
 
 
 void ConstantEvaluator::VisitLogicalExpression(LogicalExpression* node) {
   if (node->op() == LogicalExpression::kAnd) {
     EvaluateExpression(node->left());
+    MaybeCheckBool();

[Vyacheslav Egorov (Google), 2017/01/30 18:30:28]

Consider making a helper:

  EvaluateBooleanExpression()

which does:

  EvaluateExpression(node->left());
  MaybeCheckBool();

[kustermann, 2017/01/31 10:39:45]

Done.

     if (Bool::Cast(result_).value()) {
       EvaluateExpression(node->right());
+      MaybeCheckBool();
     }
   } else {
     ASSERT(node->op() == LogicalExpression::kOr);
     EvaluateExpression(node->left());
+    MaybeCheckBool();
     if (!Bool::Cast(result_).value()) {
       EvaluateExpression(node->right());
+      MaybeCheckBool();
     }
   }
 }
 
 
 void ConstantEvaluator::VisitNot(Not* node) {
   EvaluateExpression(node->expression());
-  ASSERT(result_.IsBool());
-  result_ =
-      Bool::Cast(result_).value() ? Bool::False().raw() : Bool::True().raw();
+  if (result_.raw() == Bool::True().raw()) {
+    result_ = Bool::False().raw();
+  } else {
+    MaybeCheckBool();
+    result_ = Bool::True().raw();
+  }
 }
 
 
 void ConstantEvaluator::VisitPropertyGet(PropertyGet* node) {
   const size_t kLengthLen = strlen("length");
 
   String* string = node->name()->string();
   if (string->size() == kLengthLen &&
       memcmp(string->buffer(), "length", kLengthLen) == 0) {
     node->receiver()->AcceptExpressionVisitor(this);
@@ skipping 714 matching lines @@
   Push(argument);
 
   argument->set_temp_index(argument->temp_index() - 1);
   ++pending_argument_count_;
 
   return Fragment(argument);
 }
 
 
 Fragment FlowGraphBuilder::Return(TokenPosition position) {
+  Fragment instructions;
+
+  instructions += MaybeCheckReturnType();

[Vyacheslav Egorov (Google), 2017/01/30 18:30:28]

Maybe "maybe" is not a good prefix because it does not tell when this is
happening.

[kustermann, 2017/01/31 10:39:45]

Done.

+
   Value* value = Pop();
   ASSERT(stack_ == NULL);
-  ReturnInstr* return_instr =
-      new (Z) ReturnInstr(TokenPosition::kNoSource, value);
+
+  ReturnInstr* return_instr = new (Z) ReturnInstr(position, value);
   if (exit_collector_ != NULL) exit_collector_->AddExit(return_instr);
-  return Fragment(return_instr).closed();
+
+  instructions <<= return_instr;
+
+  return instructions.closed();
 }
 
 
 Fragment FlowGraphBuilder::StaticCall(TokenPosition position,
                                       const Function& target,
                                       intptr_t argument_count) {
   return StaticCall(position, target, argument_count, Array::null_array());
 }
 
 
@@ skipping 50 matching lines @@
       class_id, kAlignedAccess, Thread::kNoDeoptId, TokenPosition::kNoSource);
   Push(store);
   return Fragment(store);
 }
 
 
 Fragment FlowGraphBuilder::StoreInstanceField(
     const dart::Field& field,
     bool is_initialization_store,
     StoreBarrierType emit_store_barrier) {
+  Fragment instructions;
+
+  const AbstractType& dst_type = AbstractType::ZoneHandle(Z, field.type());
+  instructions +=
+      MaybeCheckAssignable(dst_type, dart::String::ZoneHandle(Z, field.name()));
+
   Value* value = Pop();
   if (value->BindsToConstant()) {
     emit_store_barrier = kNoStoreBarrier;
   }
+
   StoreInstanceFieldInstr* store = new (Z)
       StoreInstanceFieldInstr(MayCloneField(Z, field), Pop(), value,
                               emit_store_barrier, TokenPosition::kNoSource);
   store->set_is_initialization(is_initialization_store);
-  return Fragment(store);
+  instructions <<= store;
+
+  return instructions;
 }
 
 
 Fragment FlowGraphBuilder::StoreInstanceFieldGuarded(
     const dart::Field& field,
     bool is_initialization_store) {
   Fragment instructions;
   const dart::Field& field_clone = MayCloneField(Z, field);
   if (FLAG_use_field_guards) {
     LocalVariable* store_expression = MakeTemporary();
@@ skipping 455 matching lines @@
     // The argument was `null` and the receiver is not the null class (we only
     // go into this branch for user-defined == operators) so we can return
     // false.
     Fragment null_fragment(null_entry);
     null_fragment += Constant(Bool::False());
     null_fragment += Return(dart_function.end_token_pos());
 
     body = Fragment(body.entry, non_null_entry);
   }
 
+  // If we run in checked mode, we have to check the type of the passed
+  // arguments.
+  if (I->type_checks()) {
+    List<VariableDeclaration>& positional = function->positional_parameters();
+    List<VariableDeclaration>& named = function->named_parameters();
+
+    for (intptr_t i = 0; i < positional.length(); i++) {
+      VariableDeclaration* variable = positional[i];
+      body += LoadLocal(LookupVariable(variable));
+      body += MaybeCheckVariableType(variable);
+      body += Drop();
+    }
+    for (intptr_t i = 0; i < named.length(); i++) {
+      VariableDeclaration* variable = named[i];
+      body += LoadLocal(LookupVariable(variable));
+      body += MaybeCheckVariableType(variable);
+      body += Drop();
+    }
+  }
+
   if (dart_function.is_native()) {
     body += NativeFunctionBody(function, dart_function);
   } else if (function->body() != NULL) {
     body += TranslateStatement(function->body());
   }
   if (body.is_open()) {
     body += NullConstant();
     body += Return(dart_function.end_token_pos());
   }
 
@@ skipping 352 matching lines @@
   return Fragment(new (Z) GuardFieldLengthInstr(Pop(), field, deopt_id));
 }
 
 
 Fragment FlowGraphBuilder::GuardFieldClass(const dart::Field& field,
                                            intptr_t deopt_id) {
   return Fragment(new (Z) GuardFieldClassInstr(Pop(), field, deopt_id));
 }
 
 
+Fragment FlowGraphBuilder::MaybeCheckVariableType(
+    VariableDeclaration* variable) {
+  if (I->type_checks()) {
+    const AbstractType& dst_type = T.TranslateType(variable->type());
+    if (dst_type.IsMalformed()) {
+      return ThrowTypeError();
+    }
+    return MaybeCheckAssignable(dst_type, H.DartSymbol(variable->name()));
+  }
+  return Fragment();
+}
+
+
+Fragment FlowGraphBuilder::EvaluateAssertion() {
+  const dart::Class& klass = dart::Class::ZoneHandle(
+      Z, dart::Library::LookupCoreClass(Symbols::AssertionError()));
+  ASSERT(!klass.IsNull());
+  const dart::Function& target =
+      dart::Function::ZoneHandle(Z, klass.LookupStaticFunctionAllowPrivate(
+                                        H.DartSymbol("_evaluateAssertion")));
+  ASSERT(!target.IsNull());
+  return StaticCall(TokenPosition::kNoSource, target, 1);
+}
+
+
+Fragment FlowGraphBuilder::MaybeCheckReturnType() {
+  if (I->type_checks()) {
+    const AbstractType& return_type =
+        AbstractType::Handle(Z, parsed_function_->function().result_type());
+    return MaybeCheckAssignable(return_type, Symbols::FunctionResult());
+  }
+  return Fragment();
+}
+
+
+Fragment FlowGraphBuilder::MaybeCheckBool() {
+  Fragment instructions;
+  if (I->type_checks()) {
+    LocalVariable* top_of_stack = MakeTemporary();
+    instructions += LoadLocal(top_of_stack);
+    instructions += AssertBool();
+    instructions += Drop();
+  }
+  return instructions;
+}
+
+
+Fragment FlowGraphBuilder::MaybeCheckAssignable(
+    const dart::AbstractType& dst_type,
+    const dart::String& dst_name) {
+  Fragment instructions;
+  if (I->type_checks() && !dst_type.IsDynamicType() &&
+      !dst_type.IsObjectType()) {
+    LocalVariable* top_of_stack = MakeTemporary();
+    instructions += LoadLocal(top_of_stack);
+    instructions += AssertAssignable(dst_type, dst_name);
+    instructions += Drop();
+  }
+  return instructions;
+}
+
+
+Fragment FlowGraphBuilder::AssertBool() {
+  Value* value = Pop();
+  AssertBooleanInstr* instr =
+      new (Z) AssertBooleanInstr(TokenPosition::kNoSource, value);
+  Push(instr);
+  return Fragment(instr);
+}
+
+
+Fragment FlowGraphBuilder::AssertAssignable(const dart::AbstractType& dst_type,
+                                            const dart::String& dst_name) {
+  Fragment instructions;
+  Value* value = Pop();
+
+  instructions += LoadInstantiatorTypeArguments();
+  Value* type_args = Pop();
+
+  AssertAssignableInstr* instr = new (Z)
+      AssertAssignableInstr(TokenPosition::kNoSource, value, type_args,
+                            dst_type, dst_name, H.thread()->GetNextDeoptId());
+  Push(instr);
+
+  instructions += Fragment(instr);
+
+  return instructions;
+}
+
+
 FlowGraph* FlowGraphBuilder::BuildGraphOfMethodExtractor(
     const Function& method) {
   // A method extractor is the implicit getter for a method.
   const Function& function =
       Function::ZoneHandle(Z, method.extracted_method_closure());
 
   TargetEntryInstr* normal_entry = BuildTargetEntry();
   graph_entry_ = new (Z)
       GraphEntryInstr(*parsed_function_, normal_entry, Compiler::kNoOSRDeoptId);
   Fragment body(normal_entry);
@@ skipping 421 matching lines @@
 #endif
   statement->AcceptStatementVisitor(this);
   DEBUG_ASSERT(context_depth_ == original_context_depth);
   return fragment_;
 }
 
 
 Fragment FlowGraphBuilder::TranslateCondition(Expression* expression,
                                               bool* negate) {
   *negate = expression->IsNot();
+  Fragment instructions;
   if (*negate) {
-    return TranslateExpression(Not::Cast(expression)->expression());
+    instructions += TranslateExpression(Not::Cast(expression)->expression());
+  } else {
+    instructions += TranslateExpression(expression);
   }
-  return TranslateExpression(expression);
+  instructions += MaybeCheckBool();
+  return instructions;
 }
 
 
 Fragment FlowGraphBuilder::TranslateExpression(Expression* expression) {
   expression->AcceptExpressionVisitor(this);
   return fragment_;
 }
 
 
 ArgumentArray FlowGraphBuilder::GetArguments(int count) {
@@ skipping 370 matching lines @@
 }
 
 
 void FlowGraphBuilder::VisitVariableGet(VariableGet* node) {
   fragment_ = LoadLocal(LookupVariable(node->variable()));
 }
 
 
 void FlowGraphBuilder::VisitVariableSet(VariableSet* node) {
   Fragment instructions = TranslateExpression(node->expression());
+  instructions += MaybeCheckVariableType(node->variable());
   instructions +=
       StoreLocal(node->position(), LookupVariable(node->variable()));
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitStaticGet(StaticGet* node) {
   Member* target = node->target();
   if (target->IsField()) {
     Field* kernel_field = Field::Cast(target);
@@ skipping 29 matching lines @@
   }
 }
 
 
 void FlowGraphBuilder::VisitStaticSet(StaticSet* node) {
   Member* target = node->target();
   if (target->IsField()) {
     Field* kernel_field = Field::Cast(target);
     const dart::Field& field =
         dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(kernel_field));
+    const AbstractType& dst_type = AbstractType::ZoneHandle(Z, field.type());
     Fragment instructions = TranslateExpression(node->expression());
+    instructions += MaybeCheckAssignable(
+        dst_type, dart::String::ZoneHandle(Z, field.name()));
     LocalVariable* variable = MakeTemporary();
     instructions += LoadLocal(variable);
     fragment_ = instructions + StoreStaticField(field);
   } else {
     ASSERT(target->IsProcedure());
 
     // Evaluate the expression on the right hand side.
     Fragment instructions = TranslateExpression(node->expression());
     LocalVariable* variable = MakeTemporary();
 
@@ skipping 250 matching lines @@
         Constant(constant_evaluator_.EvaluateConstructorInvocation(node));
     return;
   }
 
   Class* kernel_class = Class::Cast(node->target()->parent());
 
   dart::Class& klass =
       dart::Class::ZoneHandle(Z, H.LookupClassByKernelClass(kernel_class));
 
   Fragment instructions;
+
+  // Check for malbounded-ness of type.
+  if (I->type_checks()) {
+    List<DartType>& kernel_type_arguments = node->arguments()->types();
+    const TypeArguments& type_arguments = T.TranslateInstantiatedTypeArguments(
+        klass, kernel_type_arguments.raw_array(),
+        kernel_type_arguments.length());
+
+    AbstractType& type = AbstractType::Handle(
+        Z, Type::New(klass, type_arguments, TokenPosition::kNoSource));
+    type = ClassFinalizer::FinalizeType(klass, type,
+                                        ClassFinalizer::kCanonicalize);
+
+    if (type.IsMalbounded()) {
+      // Evaluate expressions for correctness.
+      List<Expression>& positional = node->arguments()->positional();
+      List<NamedExpression>& named = node->arguments()->named();
+      for (intptr_t i = 0; i < positional.length(); ++i) {
+        instructions += TranslateExpression(positional[i]);
+        instructions += Drop();
+      }
+      for (intptr_t i = 0; i < named.length(); ++i) {
+        instructions += TranslateExpression(named[i]->expression());
+        instructions += Drop();
+      }
+
+      // Throw an error & keep the [Value] on the stack.
+      instructions += ThrowTypeError();
+
+      // Bail out early.
+      fragment_ = instructions;
+      return;
+    }
+  }
+
   if (klass.NumTypeArguments() > 0) {
     List<DartType>& kernel_type_arguments = node->arguments()->types();
     const TypeArguments& type_arguments = T.TranslateInstantiatedTypeArguments(
         klass, kernel_type_arguments.raw_array(),
         kernel_type_arguments.length());
     if (!klass.IsGeneric()) {
       Type& type = Type::ZoneHandle(Z, T.ReceiverType(klass).raw());
 
       // TODO(27590): Can we move this code into [ReceiverType]?
       type ^= ClassFinalizer::FinalizeType(*active_class_.klass, type,
@@ skipping 184 matching lines @@
   right_fragment += Goto(join);
   constant_fragment += Goto(join);
 
   fragment_ = Fragment(instructions.entry, join) +
               LoadLocal(parsed_function_->expression_temp_var());
 }
 
 
 void FlowGraphBuilder::VisitNot(Not* node) {
   Fragment instructions = TranslateExpression(node->expression());
-  fragment_ = instructions + BooleanNegate();
+  instructions += MaybeCheckBool();
+  instructions += BooleanNegate();
+  fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitThisExpression(ThisExpression* node) {
   fragment_ = LoadLocal(scopes_->this_variable);
 }
 
 
 void FlowGraphBuilder::VisitStringConcatenation(StringConcatenation* node) {
   List<Expression>& expressions = node->expressions();
@@ skipping 233 matching lines @@
 
 void FlowGraphBuilder::VisitVariableDeclaration(VariableDeclaration* node) {
   LocalVariable* variable = LookupVariable(node);
   Expression* initializer = node->initializer();
 
   Fragment instructions;
   if (initializer == NULL) {
     instructions += NullConstant();
   } else {
     if (node->IsConst()) {
+      // FIXME(checked-mode)

[Vyacheslav Egorov (Google), 2017/01/30 18:30:28]

Needs to be 

// TODO(issue-number) some comment

[kustermann, 2017/01/31 10:39:45]

I'll remove the TODO. The ConstantEvaluator has been modified to result in a
compile time error if the types don't match.

       const Instance& constant_value =
           constant_evaluator_.EvaluateExpression(initializer);
       variable->SetConstValue(constant_value);
       instructions += Constant(constant_value);
     } else {
       instructions += TranslateExpression(initializer);
+      instructions += MaybeCheckVariableType(node);
     }
   }
   instructions += StoreLocal(variable->token_pos(), variable);
   instructions += Drop();
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitFunctionDeclaration(FunctionDeclaration* node) {
   Fragment instructions = TranslateFunctionNode(node->function(), node);
@@ skipping 444 matching lines @@
 
 void FlowGraphBuilder::VisitAssertStatement(AssertStatement* node) {
   if (!I->asserts()) {
     fragment_ = Fragment();
     return;
   }
 
   TargetEntryInstr* then;
   TargetEntryInstr* otherwise;
 
-  bool negate;
   Fragment instructions;
-  instructions += TranslateCondition(node->condition(), &negate);
-  instructions += BranchIfTrue(&then, &otherwise, negate);
+  // Asserts can be of the following two kinds:
+  //
+  //    * `assert(expr)`
+  //    * `assert(() { ... })`
+  //
+  // The call to `_AssertionError._evaluateAssertion()` will take care of both
+  // and returns a boolean.
+  instructions += TranslateExpression(node->condition());
+  instructions += PushArgument();
+  instructions += EvaluateAssertion();
+  instructions += MaybeCheckBool();
+  instructions += Constant(Bool::True());
+  instructions += BranchIfEqual(&then, &otherwise, false);
 
   const dart::Class& klass = dart::Class::ZoneHandle(
       Z, dart::Library::LookupCoreClass(Symbols::AssertionError()));
   ASSERT(!klass.IsNull());
   const dart::Function& constructor = dart::Function::ZoneHandle(
       Z, klass.LookupConstructorAllowPrivate(
              H.DartSymbol("_AssertionError._create")));
   ASSERT(!constructor.IsNull());
 
   const dart::String& url = H.DartString(
       parsed_function_->function().ToLibNamePrefixedQualifiedCString(),
       Heap::kOld);
 
   // Create instance of _AssertionError
   Fragment otherwise_fragment(otherwise);
   otherwise_fragment += AllocateObject(klass, 0);
   LocalVariable* instance = MakeTemporary();
 
   // Call _AssertionError._create constructor.
   otherwise_fragment += LoadLocal(instance);
   otherwise_fragment += PushArgument();  // this
 
-  otherwise_fragment +=
-      node->message() != NULL
-          ? TranslateExpression(node->message())
-          : Constant(H.DartString("<no message>", Heap::kOld));
+  otherwise_fragment += Constant(H.DartString("<no message>", Heap::kOld));
   otherwise_fragment += PushArgument();  // failedAssertion
 
   otherwise_fragment += Constant(url);
   otherwise_fragment += PushArgument();  // url
 
   otherwise_fragment += IntConstant(0);
   otherwise_fragment += PushArgument();  // line
 
   otherwise_fragment += IntConstant(0);
   otherwise_fragment += PushArgument();  // column
 
-  otherwise_fragment += Constant(H.DartString("<no message>", Heap::kOld));
+  otherwise_fragment +=
+      node->message() != NULL
+          ? TranslateExpression(node->message())
+          : Constant(H.DartString("<no message>", Heap::kOld));
   otherwise_fragment += PushArgument();  // message
 
   otherwise_fragment += StaticCall(TokenPosition::kNoSource, constructor, 6);
   otherwise_fragment += Drop();
 
   // Throw _AssertionError exception.
   otherwise_fragment += PushArgument();
   otherwise_fragment += ThrowException(TokenPosition::kNoSource);
   otherwise_fragment += Drop();
 
@@ skipping 442 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)