VM: [Kernel] Remove special-casing in FGB which is now handled by the frontend

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 1503 matching lines @@
 
   // Dart does not support generic methods yet.
   ASSERT(kernel_arguments->types().length() == 0);
 
   const dart::Instance& receiver = EvaluateExpression(node->receiver());
   dart::Class& klass = dart::Class::Handle(
       Z, isolate_->class_table()->At(receiver.GetClassId()));
   ASSERT(!klass.IsNull());
 
   // Search the superclass chain for the selector.
-  // TODO(27590): Can we assume this will never be a no-such-method error?
   dart::Function& function = dart::Function::Handle(Z);
   const dart::String& method_name = H.DartMethodName(node->name());
   while (!klass.IsNull()) {
     function = klass.LookupDynamicFunctionAllowPrivate(method_name);
     if (!function.IsNull()) break;
     klass = klass.SuperClass();
   }
+
+  // The frontend should guarantee that [MethodInvocation]s inside constant
+  // expressions are always valid.
   ASSERT(!function.IsNull());
 
   // Run the method and canonicalize the result.
   const Object& result = RunFunction(function, kernel_arguments, &receiver);
   result_ ^= result.raw();
   result_ = H.Canonicalize(result_);
 }
 
 
 void ConstantEvaluator::VisitStaticGet(StaticGet* node) {
@@ skipping 2189 matching lines @@
     arguments->data()[i] = stack_->definition()->AsPushArgument();
     Drop();
   }
   pending_argument_count_ -= count;
   ASSERT(pending_argument_count_ >= 0);
   return arguments;
 }
 
 
 void FlowGraphBuilder::VisitInvalidExpression(InvalidExpression* node) {
-  // TODO(27590): Once we have better error information we might need to
-  // make some invalid expressions not NSM errors but type/compile-time/...
-  // errors.
+  // The frontend will take care of emitting normal errors (like
+  // [NoSuchMethodError]s) and only emit [InvalidExpression]s in very special
+  // situations (e.g. an invalid annotation).
   fragment_ = ThrowNoSuchMethodError();
 }
 
 
 void FlowGraphBuilder::VisitNullLiteral(NullLiteral* node) {
   fragment_ = Constant(Instance::ZoneHandle(Z, Instance::null()));
 }
 
 
 void FlowGraphBuilder::VisitBoolLiteral(BoolLiteral* node) {
@@ skipping 266 matching lines @@
 }
 
 
 void FlowGraphBuilder::VisitVariableGet(VariableGet* node) {
   fragment_ = LoadLocal(LookupVariable(node->variable()));
 }
 
 
 void FlowGraphBuilder::VisitVariableSet(VariableSet* node) {
   Fragment instructions = TranslateExpression(node->expression());
-  // The IR should not include assignments to final or const variables.
-  // This is https://github.com/dart-lang/rasta/issues/83.
-  //
-  // TODO(27590): simply ASSERT that the variable is not const or final
-  // when that issue is fixed.
-  fragment_ = instructions +
-              ((node->variable()->IsFinal() || node->variable()->IsConst())
-                   ? Drop() + ThrowNoSuchMethodError()
-                   : StoreLocal(LookupVariable(node->variable())));
+  instructions += StoreLocal(LookupVariable(node->variable()));
+  fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitStaticGet(StaticGet* 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));
     if (kernel_field->IsConst()) {
       fragment_ = Constant(constant_evaluator_.EvaluateExpression(node));
     } else {
       const dart::Class& owner = dart::Class::Handle(Z, field.Owner());
       const dart::String& getter_name = H.DartGetterName(kernel_field->name());
       const Function& getter =
           Function::ZoneHandle(Z, owner.LookupStaticFunction(getter_name));
       if (getter.IsNull() || !field.has_initializer()) {
         Fragment instructions = Constant(field);
         fragment_ = instructions + LoadStaticField();
       } else {
-        // TODO(27590): figure out how to trigger this case and add tests.

[kustermann, 2016/11/02 18:41:34]

Not sure why this one was here. We hit this case e.g. in:

  var toplevel = '${1 + 2 + 4 + 9}';

  main() {
    print(toplevel);
  }

(i.e. non-simple initializers will make the kernel_reader create a getter which
we'll find here and invoke).

         fragment_ = StaticCall(getter, 0);
       }
     }
   } else {
     Procedure* procedure = Procedure::Cast(target);
     const Function& target = Function::ZoneHandle(
         Z, H.LookupStaticMethodByKernelProcedure(procedure));
 
     if (procedure->kind() == Procedure::kGetter) {
       fragment_ = StaticCall(target, 0);
@@ skipping 119 matching lines @@
 void FlowGraphBuilder::VisitStaticInvocation(StaticInvocation* node) {
   const Function& target = Function::ZoneHandle(
       Z, H.LookupStaticMethodByKernelProcedure(node->procedure()));
   const dart::Class& klass = dart::Class::ZoneHandle(Z, target.Owner());
   intptr_t argument_count = node->arguments()->count();
   if (target.IsGenerativeConstructor() || target.IsFactory()) {
     // The VM requires a TypeArguments object as first parameter for
     // every factory constructor.
     ++argument_count;
   }
+
   List<NamedExpression>& named = node->arguments()->named();
   const Array& argument_names = H.ArgumentNames(&named);
 
+  // The frontend ensures we the [StaticInvocation] has matching arguments.
+  ASSERT(target.AreValidArguments(argument_count, argument_names, NULL));
+
   Fragment instructions;
-  if (!target.AreValidArguments(argument_count, argument_names, NULL)) {
-    // An argument mismatch for a static invocation really should not occur
-    // in the IR.  This is issue https://github.com/dart-lang/rasta/issues/76.
-    //
-    // TODO(27590): Change this to an ASSERT when that issue is fixed.
-    List<Expression>& positional = node->arguments()->positional();
-    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();
-    }
-
-    fragment_ = instructions + ThrowNoSuchMethodError();
-    return;
-  }
-
   LocalVariable* instance_variable = NULL;
 
   // If we cross the Kernel -> VM core library boundary, a [StaticInvocation]
   // can appear, but the thing we're calling is not a static method, but a
   // factory constructor.
   // The `H.LookupStaticmethodByKernelProcedure` will potentially resolve to the
   // forwarded constructor.
   // In that case we'll make an instance and pass it as first argument.
   //
   // TODO(27590): Get rid of this after we're using core libraries compiled
@@ skipping 1431 matching lines @@
   instructions += LoadLocal(closure);
   instructions += LoadLocal(parsed_function_->current_context_var());
   instructions += StoreInstanceField(Closure::context_offset());
 
   return instructions;
 }
 
 
 }  // namespace kernel
 }  // namespace dart