Add typedef AST node boilerplate.

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 197 matching lines @@
   canonical_name_ = reader->ReadCanonicalNameReference();
   name_ = Reference::ReadStringFrom(reader);
   import_uri_ = canonical_name_->name();
   source_uri_index_ = reader->ReadUInt();
   reader->set_current_script_id(source_uri_index_);
 
   int num_imports = reader->ReadUInt();
   if (num_imports != 0) {
     FATAL("Deferred imports not implemented in VM");
   }
+  int num_typedefs = reader->ReadUInt();
+  typedefs().EnsureInitialized(num_typedefs);
+  for (intptr_t i = 0; i < num_typedefs; i++) {
+    typedefs().GetOrCreate<Typedef>(i, this)->ReadFrom(reader);
+  }
   int num_classes = reader->ReadUInt();
   classes().EnsureInitialized(num_classes);
   for (intptr_t i = 0; i < num_classes; i++) {
     Tag tag = reader->ReadTag();
     ASSERT(tag == kClass);
     NormalClass* klass = classes().GetOrCreate<NormalClass>(i, this);
     klass->ReadFrom(reader);
   }
 
   fields().ReadFrom<Field>(reader, this);
   procedures().ReadFrom<Procedure>(reader, this);
   return this;
 }
 
 
+Typedef* Typedef::ReadFrom(Reader* reader) {
+  TRACE_READ_OFFSET();
+
+  canonical_name_ = reader->ReadCanonicalNameReference();
+  position_ = reader->ReadPosition(false);
+  name_ = Reference::ReadStringFrom(reader);
+  source_uri_index_ = reader->ReadUInt();
+  type_parameters_.ReadFrom(reader);
+  type_ = DartType::ReadFrom(reader);
+
+  return this;
+}
+
+
 Class* Class::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
 
   canonical_name_ = reader->ReadCanonicalNameReference();
   position_ = reader->ReadPosition(false);
   is_abstract_ = reader->ReadBool();
   name_ = Reference::ReadStringFrom(reader);
   source_uri_index_ = reader->ReadUInt();
   reader->set_current_script_id(source_uri_index_);
   reader->record_token_position(position_);
@@ skipping 63 matching lines @@
   }
 
   if (canonical_name != NULL) {
     canonical_name->set_referenced(true);
   }
 
   return canonical_name;
 }
 
 
+CanonicalName* Reference::ReadTypedefFrom(Reader* reader) {
+  TRACE_READ_OFFSET();
+
+  CanonicalName* canonical_name = reader->ReadCanonicalNameReference();
+  if (canonical_name == NULL) {
+    FATAL("Expected a valid typedef reference, but got `null`");
+  }
+
+  canonical_name->set_referenced(true);
+
+  return canonical_name;
+}
+
+
 String* Reference::ReadStringFrom(Reader* reader) {
   int index = reader->ReadUInt();
   return reader->helper()->program()->string_table().strings()[index];
 }
 
 
 Field* Field::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   kernel_offset_ = reader->offset();  // Notice the ReadTag() below.
   Tag tag = reader->ReadTag();
@@ skipping 1078 matching lines @@
     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);
+    case kTypedefType:
+      return TypedefType::ReadFrom(reader);
     default:
       UNREACHABLE();
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 InvalidType* InvalidType::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
@@ skipping 25 matching lines @@
 InterfaceType* InterfaceType::ReadFrom(Reader* reader,
                                        bool _without_type_arguments_) {
   TRACE_READ_OFFSET();
   CanonicalName* klass_name = Reference::ReadClassFrom(reader);
   InterfaceType* type = new InterfaceType(klass_name);
   ASSERT(_without_type_arguments_);
   return type;
 }
 
 
+TypedefType* TypedefType::ReadFrom(Reader* reader) {
+  TRACE_READ_OFFSET();
+  CanonicalName* typedef_name = Reference::ReadTypedefFrom(reader);
+  TypedefType* type = new TypedefType(typedef_name);
+  type->type_arguments().ReadFromStatic<DartType>(reader);
+  return type;
+}
+
+
 FunctionType* FunctionType::ReadFrom(Reader* reader) {
   TRACE_READ_OFFSET();
   FunctionType* type = new FunctionType();
   TypeParameterScope<ReaderHelper> scope(reader->helper());
   type->type_parameters().ReadFrom(reader);
   type->required_parameter_count_ = reader->ReadUInt();
   type->positional_parameters().ReadFromStatic<DartType>(reader);
   type->named_parameters().ReadFromStatic<Tuple<String, DartType> >(reader);
   type->return_type_ = DartType::ReadFrom(reader);
   return type;
@@ skipping 111 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)