Serialize erroneous element and more

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 '../elements/modelx.dart' show ErroneousElementX;
 import 'constant_serialization.dart';
 import 'keys.dart';
 import 'modelz.dart';
 import 'serialization.dart';
 import 'serialization_util.dart';
 
 /// Enum kinds used for encoding [Element]s.
 enum SerializedElementKind {
+  ERROR,
   LIBRARY,
   COMPILATION_UNIT,
   CLASS,
   ENUM,
   NAMED_MIXIN_APPLICATION,
   GENERATIVE_CONSTRUCTOR,
   DEFAULT_CONSTRUCTOR,
   FACTORY_CONSTRUCTOR,
   REDIRECTING_FACTORY_CONSTRUCTOR,
   FORWARDING_CONSTRUCTOR,
@@ skipping 26 matching lines @@
 }
 
 /// 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 ErrorSerializer(),
   const LibrarySerializer(),
   const CompilationUnitSerializer(),
   const ClassSerializer(),
   const ConstructorSerializer(),
   const FieldSerializer(),
   const FunctionSerializer(),
   const TypedefSerializer(),
   const TypeVariableSerializer(),
   const ParameterSerializer(),
   const ImportSerializer(),
@@ skipping 110 matching lines @@
         if (abstractField.setter != null) {
           set.add(abstractField.setter);
         }
       } else {
         set.add(element);
       }
     };
   }
 }
 
+class ErrorSerializer implements ElementSerializer {
+  const ErrorSerializer();
+
+  SerializedElementKind getSerializedKind(Element element) {
+    if (element.isError) {
+      return SerializedElementKind.ERROR;
+    }
+    return null;
+  }
+
+  void serialize(ErroneousElement element, ObjectEncoder encoder,
+      SerializedElementKind kind) {
+    encoder.setElement(Key.ENCLOSING, element.enclosingElement);
+    encoder.setString(Key.NAME, element.name);
+    encoder.setEnum(Key.MESSAGE_KIND, element.messageKind);
+    if (element.messageArguments.isNotEmpty) {
+      MapEncoder mapEncoder = encoder.createMap(Key.ARGUMENTS);
+      element.messageArguments.forEach((String key, String value) {
+        mapEncoder.setString(key, value);
+      });
+    }
+  }
+}
+
 class LibrarySerializer implements ElementSerializer {
   const LibrarySerializer();
 
   SerializedElementKind getSerializedKind(Element element) {
     if (element.isLibrary) {
       return SerializedElementKind.LIBRARY;
     }
     return null;
   }
 
@@ skipping 492 matching lines @@
 class ElementDeserializer {
   /// Deserializes an [Element] from an [ObjectDecoder].
   ///
   /// The class is called from the [Deserializer] when an [Element]
   /// needs deserialization. The [ObjectDecoder] ensures that any [Element],
   /// [DartType], and [ConstantExpression] that the deserialized [Element]
   /// depends upon are available.
   static Element deserialize(
       ObjectDecoder decoder, SerializedElementKind elementKind) {
     switch (elementKind) {
+      case SerializedElementKind.ERROR:
+        Element enclosing = decoder.getElement(Key.ENCLOSING);
+        String name = decoder.getString(Key.NAME);
+        MessageKind messageKind =
+            decoder.getEnum(Key.MESSAGE_KIND, MessageKind.values);
+        Map<String, String> arguments = <String, String>{};
+        MapDecoder mapDecoder = decoder.getMap(Key.ARGUMENTS, isOptional: true);
+        if (mapDecoder != null) {
+          mapDecoder.forEachKey((String key) {
+            arguments[key] = mapDecoder.getString(key);
+          });
+        }
+        return new ErroneousElementX(messageKind, arguments, name, enclosing);
       case SerializedElementKind.LIBRARY:
         return new LibraryElementZ(decoder);
       case SerializedElementKind.COMPILATION_UNIT:
         return new CompilationUnitElementZ(decoder);
       case SerializedElementKind.CLASS:
         return new ClassElementZ(decoder);
       case SerializedElementKind.ENUM:
         return new EnumClassElementZ(decoder);
       case SerializedElementKind.NAMED_MIXIN_APPLICATION:
         return new NamedMixinApplicationElementZ(decoder);
@@ skipping 54 matching lines @@
         return new LocalVariableElementZ(decoder);
       case SerializedElementKind.EXTERNAL_LIBRARY:
       case SerializedElementKind.EXTERNAL_LIBRARY_MEMBER:
       case SerializedElementKind.EXTERNAL_CLASS_MEMBER:
       case SerializedElementKind.EXTERNAL_CONSTRUCTOR:
         break;
     }
     throw new UnsupportedError("Unexpected element kind '${elementKind}.");
   }
 }