Add Kernel AST nodes for Vector and Closure primitives in VM

runtime/vm/kernel_binary.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.
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include "vm/kernel_binary.h"
 #include "platform/globals.h"
 #include "vm/flags.h"
 #include "vm/growable_array.h"
 #include "vm/kernel.h"
@@ skipping 464 matching lines @@
     case kMapLiteral:
       return MapLiteral::ReadFrom(reader, false);
     case kConstMapLiteral:
       return MapLiteral::ReadFrom(reader, true);
     case kAwaitExpression:
       return AwaitExpression::ReadFrom(reader);
     case kFunctionExpression:
       return FunctionExpression::ReadFrom(reader);
     case kLet:
       return Let::ReadFrom(reader);
+    case kVectorCreation:
+      return VectorCreation::ReadFrom(reader);
+    case kVectorGet:
+      return VectorGet::ReadFrom(reader);
+    case kVectorSet:
+      return VectorSet::ReadFrom(reader);
+    case kVectorCopy:
+      return VectorCopy::ReadFrom(reader);
+    case kClosureCreation:
+      return ClosureCreation::ReadFrom(reader);
     case kBigIntLiteral:
       return BigintLiteral::ReadFrom(reader);
     case kStringLiteral:
       return StringLiteral::ReadFrom(reader);
     case kSpecialIntLiteral:
       return IntLiteral::ReadFrom(reader, payload);
     case kNegativeIntLiteral:
       return IntLiteral::ReadFrom(reader, true);
     case kPositiveIntLiteral:
       return IntLiteral::ReadFrom(reader, false);
@@ skipping 434 matching lines @@
   let->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
   let->variable_ = VariableDeclaration::ReadFromImpl(reader, false);
   let->body_ = Expression::ReadFrom(reader);
   let->position_ = reader->min_position();
   let->end_position_ = reader->max_position();
 
   return let;
 }
 
 
+VectorCreation* VectorCreation::ReadFrom(Reader* reader) {
+  TRACE_READ_OFFSET();
+  PositionScope scope(reader);
+
+  VectorCreation* vector_creation = new VectorCreation();
+  vector_creation->kernel_offset_ =
+      reader->offset() - 1;  // -1 to include tag byte.
+  vector_creation->value_ = static_cast<int64_t>(reader->ReadUInt());
+  vector_creation->position_ = reader->min_position();
+  vector_creation->end_position_ = reader->max_position();
+
+  return vector_creation;
+}
+
+
+VectorGet* VectorGet::ReadFrom(Reader* reader) {
+  TRACE_READ_OFFSET();
+  PositionScope scope(reader);
+
+  VectorGet* vector_get = new VectorGet();
+  vector_get->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
+  vector_get->vector_expression_ = Expression::ReadFrom(reader);
+  vector_get->index_ = static_cast<int64_t>(reader->ReadUInt());
+  vector_get->position_ = reader->min_position();
+  vector_get->end_position_ = reader->max_position();
+
+  return vector_get;
+}
+
+
+VectorSet* VectorSet::ReadFrom(Reader* reader) {
+  TRACE_READ_OFFSET();
+  PositionScope scope(reader);
+
+  VectorSet* vector_set = new VectorSet();
+  vector_set->kernel_offset_ = reader->offset() - 1;  // -1 to include tag byte.
+  vector_set->vector_expression_ = Expression::ReadFrom(reader);
+  vector_set->index_ = static_cast<int64_t>(reader->ReadUInt());
+  vector_set->value_ = Expression::ReadFrom(reader);
+  vector_set->position_ = reader->min_position();
+  vector_set->end_position_ = reader->max_position();
+
+  return vector_set;
+}
+
+
+VectorCopy* VectorCopy::ReadFrom(Reader* reader) {
+  TRACE_READ_OFFSET();
+  PositionScope scope(reader);
+
+  VectorCopy* vector_copy = new VectorCopy();
+  vector_copy->kernel_offset_ =
+      reader->offset() - 1;  // -1 to include tag byte.
+  vector_copy->vector_expression_ = Expression::ReadFrom(reader);
+  vector_copy->position_ = reader->min_position();
+  vector_copy->end_position_ = reader->max_position();
+
+  return vector_copy;
+}
+
+
+ClosureCreation* ClosureCreation::ReadFrom(Reader* reader) {
+  TRACE_READ_OFFSET();
+  PositionScope scope(reader);
+
+  ClosureCreation* closure_creation = new ClosureCreation();
+  closure_creation->kernel_offset_ =
+      reader->offset() - 1;  // to include tag byte.
+  closure_creation->top_level_function_reference_ =
+      Reference::ReadMemberFrom(reader);
+  closure_creation->context_vector_ = Expression::ReadFrom(reader);
+  closure_creation->function_type_ =
+      FunctionType::Cast(DartType::ReadFrom(reader));
+  closure_creation->position_ = reader->min_position();
+  closure_creation->end_position_ = reader->max_position();
+
+  return closure_creation;
+}
+
+
 Statement* Statement::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   Tag tag = reader->ReadTag();
   switch (tag) {
     case kInvalidStatement:
       return InvalidStatement::ReadFrom(reader);
     case kExpressionStatement:
       return ExpressionStatement::ReadFrom(reader);
     case kBlock:
       return Block::ReadFromImpl(reader);
@@ skipping 342 matching lines @@
     case kInterfaceType:
       return InterfaceType::ReadFrom(reader);
     case kSimpleInterfaceType:
       return InterfaceType::ReadFrom(reader, true);
     case kFunctionType:
       return FunctionType::ReadFrom(reader);
     case kSimpleFunctionType:
       return FunctionType::ReadFrom(reader, true);
     case kTypeParameterType:
       return TypeParameterType::ReadFrom(reader);
+    case kVectorType:
+      return VectorType::ReadFrom(reader);
     default:
       UNREACHABLE();
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 InvalidType* InvalidType::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
@@ skipping 58 matching lines @@
 
 TypeParameterType* TypeParameterType::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   TypeParameterType* type = new TypeParameterType();
   type->parameter_ =
       reader->helper()->type_parameters().Lookup(reader->ReadUInt());
   return type;
 }
 
 
+VectorType* VectorType::ReadFrom(Reader* reader) {
+  TRACE_READ_OFFSET();
+  VectorType* type = new VectorType();
+  return type;
+}
+
+
 Program* Program::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   uint32_t magic = reader->ReadUInt32();
   if (magic != kMagicProgramFile) FATAL("Invalid magic identifier");
 
   Program* program = new Program();
   program->canonical_name_root_ = CanonicalName::NewRoot();
   reader->helper()->set_program(program);
 
   program->string_table_.ReadFrom(reader);
@@ skipping 69 matching lines @@
 
 kernel::Program* ReadPrecompiledKernelFromBuffer(const uint8_t* buffer,
                                                  intptr_t buffer_length) {
   kernel::Reader reader(buffer, buffer_length);
   return kernel::Program::ReadFrom(&reader);
 }
 
 
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)