Update elements, nodes and visitors for serialization.

pkg/compiler/lib/src/serialization/element_serialization.dart

 // Copyright (c) 2015, 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.
 
 library dart2js.serialization.elements;
 
 import '../common.dart';
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import 'constant_serialization.dart';
 import 'keys.dart';
 import 'modelz.dart';
 import 'serialization.dart';
 
 /// Enum kinds used for encoding [Element]s.
 enum SerializedElementKind {
   LIBRARY,
   COMPILATION_UNIT,
   CLASS,
   ENUM,
   NAMED_MIXIN_APPLICATION,
   GENERATIVE_CONSTRUCTOR,
   FACTORY_CONSTRUCTOR,
   TOPLEVEL_FIELD,
   STATIC_FIELD,
   INSTANCE_FIELD,
+  ENUM_CONSTANT,
   TOPLEVEL_FUNCTION,
   TOPLEVEL_GETTER,
   TOPLEVEL_SETTER,
   STATIC_FUNCTION,
   STATIC_GETTER,
   STATIC_SETTER,
   INSTANCE_FUNCTION,
   INSTANCE_GETTER,
   INSTANCE_SETTER,
   LOCAL_FUNCTION,
   TYPEDEF,
   TYPEVARIABLE,
   PARAMETER,
   INITIALIZING_FORMAL,
   IMPORT,
   EXPORT,
   PREFIX,
+  LOCAL_VARIABLE,
   EXTERNAL_LIBRARY,
   EXTERNAL_LIBRARY_MEMBER,
   EXTERNAL_STATIC_MEMBER,
   EXTERNAL_CONSTRUCTOR,
 }
 
 /// Set of serializers used to serialize different kinds of elements by
 /// encoding into them into [ObjectEncoder]s.
 ///
 /// This class is called from the [Serializer] when an [Element] needs
 /// serialization. The [ObjectEncoder] ensures that any [Element], [DartType],
 /// and [ConstantExpression] that the serialized [Element] depends upon are also
 /// serialized.
 const List<ElementSerializer> ELEMENT_SERIALIZERS = const [
   const LibrarySerializer(),
   const CompilationUnitSerializer(),
   const ClassSerializer(),
   const ConstructorSerializer(),
   const FieldSerializer(),
   const FunctionSerializer(),
   const TypedefSerializer(),
   const TypeVariableSerializer(),
   const ParameterSerializer(),
   const ImportSerializer(),
   const ExportSerializer(),
   const PrefixSerializer(),
+  const LocalVariableSerializer(),
 ];
 
 /// Interface for a function that can serialize a set of element kinds.
 abstract class ElementSerializer {
   /// Returns the [SerializedElementKind] for [element] if this serializer
   /// supports serialization of [element] or `null` otherwise.
   SerializedElementKind getSerializedKind(Element element);
 
   /// Serializes [element] into the [encoder] using the [kind] computed
   /// by [getSerializedKind].
@@ skipping 264 matching lines @@
     }
   }
 }
 
 class FieldSerializer implements ElementSerializer {
   const FieldSerializer();
 
   SerializedElementKind getSerializedKind(Element element) {
     if (element.isField) {
       if (element.isTopLevel) return SerializedElementKind.TOPLEVEL_FIELD;
-      if (element.isStatic) return SerializedElementKind.STATIC_FIELD;
+      if (element.isStatic) {
+        if (element is EnumConstantElement) {
+          return SerializedElementKind.ENUM_CONSTANT;
+        }
+        return SerializedElementKind.STATIC_FIELD;
+      }
       if (element.isInstanceMember) return SerializedElementKind.INSTANCE_FIELD;
     }
     return null;
   }
 
   void serialize(
       FieldElement element, ObjectEncoder encoder, SerializedElementKind kind) {
     encoder.setString(Key.NAME, element.name);
     SerializerUtil.serializePosition(element, encoder);
     encoder.setType(Key.TYPE, element.type);
     encoder.setBool(Key.IS_FINAL, element.isFinal);
     encoder.setBool(Key.IS_CONST, element.isConst);
     if (element.isConst) {
       ConstantExpression constant = element.constant;
       encoder.setConstant(Key.CONSTANT, constant);
     }
     if (kind != SerializedElementKind.TOPLEVEL_FIELD) {
       encoder.setElement(Key.CLASS, element.enclosingClass);
     } else {
       encoder.setElement(Key.LIBRARY, element.library);
       encoder.setElement(Key.COMPILATION_UNIT, element.compilationUnit);
     }
+    if (element is EnumConstantElement) {
+      EnumConstantElement enumConstant = element;
+      encoder.setInt(Key.INDEX, enumConstant.index);
+    }
   }
 }
 
 class FunctionSerializer implements ElementSerializer {
   const FunctionSerializer();
 
   SerializedElementKind getSerializedKind(Element element) {
     if (element.isFunction) {
       if (element.isTopLevel) return SerializedElementKind.TOPLEVEL_FUNCTION;
       if (element.isStatic) return SerializedElementKind.STATIC_FUNCTION;
@@ skipping 110 matching lines @@
     if (element.isOptional) {
       encoder.setConstant(Key.CONSTANT, element.constant);
     }
     if (element.isInitializingFormal) {
       InitializingFormalElement initializingFormal = element;
       encoder.setElement(Key.FIELD, initializingFormal.fieldElement);
     }
   }
 }
 
+class LocalVariableSerializer implements ElementSerializer {
+  const LocalVariableSerializer();
+
+  SerializedElementKind getSerializedKind(Element element) {
+    if (element.isVariable) {
+      return SerializedElementKind.LOCAL_VARIABLE;
+    }
+    return null;
+  }
+
+  void serialize(LocalVariableElement element, ObjectEncoder encoder,
+      SerializedElementKind kind) {
+    encoder.setString(Key.NAME, element.name);
+    SerializerUtil.serializePosition(element, encoder);
+    encoder.setType(Key.TYPE, element.type);
+    encoder.setBool(Key.IS_FINAL, element.isFinal);
+    encoder.setBool(Key.IS_CONST, element.isConst);
+    if (element.isConst) {
+      ConstantExpression constant = element.constant;
+      encoder.setConstant(Key.CONSTANT, constant);
+    }
+    encoder.setElement(Key.EXECUTABLE_CONTEXT, element.executableContext);
+  }
+}
+
 class ImportSerializer implements ElementSerializer {
   const ImportSerializer();
 
   SerializedElementKind getSerializedKind(Element element) {
     if (element.isImport) {
       return SerializedElementKind.IMPORT;
     }
     return null;
   }
 
@@ skipping 73 matching lines @@
       case SerializedElementKind.CLASS:
         return new ClassElementZ(decoder);
       case SerializedElementKind.ENUM:
         return new EnumClassElementZ(decoder);
       case SerializedElementKind.NAMED_MIXIN_APPLICATION:
         return new NamedMixinApplicationElementZ(decoder);
       case SerializedElementKind.TOPLEVEL_FIELD:
         return new TopLevelFieldElementZ(decoder);
       case SerializedElementKind.STATIC_FIELD:
         return new StaticFieldElementZ(decoder);
+      case SerializedElementKind.ENUM_CONSTANT:
+        return new EnumConstantElementZ(decoder);
       case SerializedElementKind.INSTANCE_FIELD:
         return new InstanceFieldElementZ(decoder);
       case SerializedElementKind.GENERATIVE_CONSTRUCTOR:
         return new GenerativeConstructorElementZ(decoder);
       case SerializedElementKind.FACTORY_CONSTRUCTOR:
         return new FactoryConstructorElementZ(decoder);
       case SerializedElementKind.TOPLEVEL_FUNCTION:
         return new TopLevelFunctionElementZ(decoder);
       case SerializedElementKind.STATIC_FUNCTION:
         return new StaticFunctionElementZ(decoder);
@@ skipping 20 matching lines @@
       case SerializedElementKind.PARAMETER:
         return new ParameterElementZ(decoder);
       case SerializedElementKind.INITIALIZING_FORMAL:
         return new InitializingFormalElementZ(decoder);
       case SerializedElementKind.IMPORT:
         return new ImportElementZ(decoder);
       case SerializedElementKind.EXPORT:
         return new ExportElementZ(decoder);
       case SerializedElementKind.PREFIX:
         return new PrefixElementZ(decoder);
+      case SerializedElementKind.LOCAL_VARIABLE:
+        return new LocalVariableElementZ(decoder);
       case SerializedElementKind.EXTERNAL_LIBRARY:
       case SerializedElementKind.EXTERNAL_LIBRARY_MEMBER:
       case SerializedElementKind.EXTERNAL_STATIC_MEMBER:
       case SerializedElementKind.EXTERNAL_CONSTRUCTOR:
         break;
     }
     throw new UnsupportedError("Unexpected element kind '${elementKind}.");
   }
 }