Revert "Remove Registry from registerMetadataConstant" and "Serialize metadata"

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';
@@ skipping 102 matching lines @@
       if (position.uri != element.compilationUnit.script.resourceUri) {
         encoder.setUri(Key.URI, element.library.canonicalUri, position.uri);
       }
       int length = position.end - position.begin;
       if (element.name.length != length) {
         encoder.setInt(Key.LENGTH, length);
       }
     }
   }
 
-  /// Serialize the metadata of [element] into [encoder].
-  static void serializeMetadata(Element element, ObjectEncoder encoder) {
-    if (element.metadata.isNotEmpty) {
-      ListEncoder list = encoder.createList(Key.METADATA);
-      for (MetadataAnnotation metadata in element.metadata) {
-        ObjectEncoder object = list.createObject();
-        object.setElement(Key.ELEMENT, metadata.annotatedElement);
-        SourceSpan sourcePosition = metadata.sourcePosition;
-        // TODO(johnniwinther): What is the base URI here?
-        object.setUri(Key.URI, sourcePosition.uri, sourcePosition.uri);
-        object.setInt(Key.OFFSET, sourcePosition.begin);
-        object.setInt(Key.LENGTH, sourcePosition.end - sourcePosition.begin);
-        object.setConstant(Key.CONSTANT, metadata.constant);
-      }
-    }
-  }
-
   /// Serialize the parent relation for [element] into [encoder], i.e library,
   /// enclosing class, and compilation unit references.
   static void serializeParentRelation(Element element, ObjectEncoder encoder) {
     if (element.enclosingClass != null) {
       encoder.setElement(Key.CLASS, element.enclosingClass);
       if (element.enclosingClass.declaration.compilationUnit !=
           element.compilationUnit) {
         encoder.setElement(Key.COMPILATION_UNIT, element.compilationUnit);
       }
     } else {
@@ skipping 85 matching lines @@
   }
 
   static List<Element> getExportedElements(LibraryElement element) {
     Set<Element> exportedElements = new Set<Element>();
     element.forEachExport(SerializerUtil.flattenElements(exportedElements));
     return exportedElements.toList();
   }
 
   void serialize(LibraryElement element, ObjectEncoder encoder,
       SerializedElementKind kind) {
-    SerializerUtil.serializeMetadata(element, encoder);
     encoder.setUri(
         Key.CANONICAL_URI, element.canonicalUri, element.canonicalUri);
     encoder.setString(Key.LIBRARY_NAME, element.libraryName);
     SerializerUtil.serializeMembers(getMembers(element), encoder);
     encoder.setElement(Key.COMPILATION_UNIT, element.entryCompilationUnit);
     encoder.setElements(Key.COMPILATION_UNITS, getCompilationUnits(element));
     encoder.setElements(Key.IMPORTS, getImports(element));
     encoder.setElements(Key.EXPORTS, element.exports);
 
     encoder.setElements(Key.IMPORT_SCOPE, getImportedElements(element));
 
     encoder.setElements(Key.EXPORT_SCOPE, getExportedElements(element));
   }
 }
 
 class CompilationUnitSerializer implements ElementSerializer {
   const CompilationUnitSerializer();
 
   SerializedElementKind getSerializedKind(Element element) {
     if (element.isCompilationUnit) {
       return SerializedElementKind.COMPILATION_UNIT;
     }
     return null;
   }
 
   void serialize(CompilationUnitElement element, ObjectEncoder encoder,
       SerializedElementKind kind) {
-    SerializerUtil.serializeMetadata(element, encoder);
     encoder.setElement(Key.LIBRARY, element.library);
     encoder.setUri(
         Key.URI, element.library.canonicalUri, element.script.resourceUri);
     List<Element> elements = <Element>[];
     element.forEachLocalMember((e) {
       if (!element.isPatch) {
         elements.add(e);
       }
     });
     encoder.setElements(Key.ELEMENTS, elements);
@@ skipping 27 matching lines @@
         if (!member.isPatch) {
           members.add(member);
         }
       });
     }
     return members;
   }
 
   void serialize(
       ClassElement element, ObjectEncoder encoder, SerializedElementKind kind) {
-    SerializerUtil.serializeMetadata(element, encoder);
     encoder.setElement(Key.LIBRARY, element.library);
     encoder.setElement(Key.COMPILATION_UNIT, element.compilationUnit);
     encoder.setString(Key.NAME, element.name);
     SerializerUtil.serializePosition(element, encoder);
     encoder.setTypes(Key.TYPE_VARIABLES, element.typeVariables);
     encoder.setBool(Key.IS_ABSTRACT, element.isAbstract);
     SerializerUtil.serializeMembers(getMembers(element), encoder);
     encoder.setBool(Key.IS_PROXY, element.isProxy);
-    encoder.setBool(Key.IS_INJECTED, element.isInjected);
     if (kind == SerializedElementKind.ENUM) {
       EnumClassElement enumClass = element;
       encoder.setElements(Key.FIELDS, enumClass.enumValues);
     }
     if (element.isObject) return;
 
     List<InterfaceType> mixins = <InterfaceType>[];
     ClassElement superclass = element.superclass;
     while (superclass.isUnnamedMixinApplication) {
       MixinApplicationElement mixinElement = superclass;
@@ skipping 41 matching lines @@
     }
     return null;
   }
 
   void serialize(ConstructorElement element, ObjectEncoder encoder,
       SerializedElementKind kind) {
     SerializerUtil.serializeParentRelation(element, encoder);
     if (kind == SerializedElementKind.FORWARDING_CONSTRUCTOR) {
       encoder.setElement(Key.ELEMENT, element.definingConstructor);
     } else {
-      SerializerUtil.serializeMetadata(element, encoder);
       encoder.setType(Key.TYPE, element.type);
       encoder.setString(Key.NAME, element.name);
       SerializerUtil.serializePosition(element, encoder);
       SerializerUtil.serializeParameters(element, encoder);
       encoder.setBool(Key.IS_CONST, element.isConst);
       encoder.setBool(Key.IS_EXTERNAL, element.isExternal);
-      encoder.setBool(Key.IS_INJECTED, element.isInjected);
       if (element.isConst && !element.isFromEnvironmentConstructor) {
         ConstantConstructor constantConstructor = element.constantConstructor;
         ObjectEncoder constantEncoder = encoder.createObject(Key.CONSTRUCTOR);
         const ConstantConstructorSerializer()
             .visit(constantConstructor, constantEncoder);
       }
       if (kind == SerializedElementKind.GENERATIVE_CONSTRUCTOR) {
         encoder.setBool(Key.IS_REDIRECTING, element.isRedirectingGenerative);
       }
       encoder.setElement(Key.EFFECTIVE_TARGET, element.effectiveTarget);
@@ skipping 25 matching lines @@
         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.serializeMetadata(element, encoder);
     SerializerUtil.serializePosition(element, encoder);
     encoder.setType(Key.TYPE, element.type);
     encoder.setBool(Key.IS_FINAL, element.isFinal);
     encoder.setBool(Key.IS_CONST, element.isConst);
-    encoder.setBool(Key.IS_INJECTED, element.isInjected);
     ConstantExpression constant = element.constant;
     if (constant != null) {
       encoder.setConstant(Key.CONSTANT, constant);
     }
     SerializerUtil.serializeParentRelation(element, encoder);
     if (element is EnumConstantElement) {
       EnumConstantElement enumConstant = element;
       encoder.setInt(Key.INDEX, enumConstant.index);
     }
   }
@@ skipping 26 matching lines @@
       if (element.isInstanceMember) {
         return SerializedElementKind.INSTANCE_SETTER;
       }
     }
     return null;
   }
 
   void serialize(FunctionElement element, ObjectEncoder encoder,
       SerializedElementKind kind) {
     encoder.setString(Key.NAME, element.name);
-    SerializerUtil.serializeMetadata(element, encoder);
     SerializerUtil.serializePosition(element, encoder);
     SerializerUtil.serializeParameters(element, encoder);
     encoder.setType(Key.TYPE, element.type);
     if (element.isFunction) {
       encoder.setBool(Key.IS_OPERATOR, element.isOperator);
       encoder.setEnum(Key.ASYNC_MARKER, element.asyncMarker);
     }
     SerializerUtil.serializeParentRelation(element, encoder);
     encoder.setBool(Key.IS_EXTERNAL, element.isExternal);
     encoder.setBool(Key.IS_ABSTRACT, element.isAbstract);
-    encoder.setBool(Key.IS_INJECTED, element.isInjected);
     if (element.isLocal) {
       LocalFunctionElement localFunction = element;
       encoder.setElement(
           Key.EXECUTABLE_CONTEXT, localFunction.executableContext);
     }
   }
 }
 
 class TypedefSerializer implements ElementSerializer {
   const TypedefSerializer();
 
   SerializedElementKind getSerializedKind(Element element) {
     if (element.isTypedef) {
       return SerializedElementKind.TYPEDEF;
     }
     return null;
   }
 
   void serialize(TypedefElement element, ObjectEncoder encoder,
       SerializedElementKind kind) {
     encoder.setString(Key.NAME, element.name);
-    SerializerUtil.serializeMetadata(element, encoder);
     SerializerUtil.serializePosition(element, encoder);
     encoder.setType(Key.ALIAS, element.alias);
     encoder.setElement(Key.LIBRARY, element.library);
     encoder.setTypes(Key.TYPE_VARIABLES, element.typeVariables);
     encoder.setElement(Key.COMPILATION_UNIT, element.compilationUnit);
   }
 }
 
 class TypeVariableSerializer implements ElementSerializer {
   const TypeVariableSerializer();
 
   SerializedElementKind getSerializedKind(Element element) {
     if (element.isTypeVariable) {
       return SerializedElementKind.TYPEVARIABLE;
     }
     return null;
   }
 
   void serialize(TypeVariableElement element, ObjectEncoder encoder,
       SerializedElementKind kind) {
     encoder.setElement(Key.TYPE_DECLARATION, element.typeDeclaration);
     encoder.setString(Key.NAME, element.name);
-    SerializerUtil.serializeMetadata(element, encoder);
     SerializerUtil.serializePosition(element, encoder);
     encoder.setType(Key.TYPE, element.type);
     encoder.setInt(Key.INDEX, element.index);
     encoder.setType(Key.BOUND, element.bound);
   }
 }
 
 class ParameterSerializer implements ElementSerializer {
   const ParameterSerializer();
 
   SerializedElementKind getSerializedKind(Element element) {
     if (element.isParameter) {
       return SerializedElementKind.PARAMETER;
     } else if (element.isInitializingFormal) {
       return SerializedElementKind.INITIALIZING_FORMAL;
     }
     return null;
   }
 
   void serialize(ParameterElement element, ObjectEncoder encoder,
       SerializedElementKind kind) {
     encoder.setElement(Key.FUNCTION, element.functionDeclaration);
     encoder.setString(Key.NAME, element.name);
-    SerializerUtil.serializeMetadata(element, encoder);
     SerializerUtil.serializePosition(element, encoder);
     encoder.setType(Key.TYPE, element.type);
     encoder.setBool(Key.IS_OPTIONAL, element.isOptional);
     encoder.setBool(Key.IS_NAMED, element.isNamed);
     encoder.setBool(Key.IS_FINAL, element.isFinal);
     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.serializeMetadata(element, encoder);
     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;
   }
 
   void serialize(ImportElement element, ObjectEncoder encoder,
       SerializedElementKind kind) {
-    SerializerUtil.serializeMetadata(element, encoder);
     encoder.setElement(Key.LIBRARY, element.library);
     encoder.setElement(Key.COMPILATION_UNIT, element.compilationUnit);
     encoder.setElement(Key.LIBRARY_DEPENDENCY, element.importedLibrary);
     if (element.prefix != null) {
       encoder.setElement(Key.PREFIX, element.prefix);
     }
     encoder.setBool(Key.IS_DEFERRED, element.isDeferred);
     // TODO(johnniwinther): What is the base for the URI?
     encoder.setUri(Key.URI, element.uri, element.uri);
   }
 }
 
 class ExportSerializer implements ElementSerializer {
   const ExportSerializer();
 
   SerializedElementKind getSerializedKind(Element element) {
     if (element.isExport) {
       return SerializedElementKind.EXPORT;
     }
     return null;
   }
 
   void serialize(ExportElement element, ObjectEncoder encoder,
       SerializedElementKind kind) {
-    SerializerUtil.serializeMetadata(element, encoder);
     encoder.setElement(Key.LIBRARY, element.library);
     encoder.setElement(Key.COMPILATION_UNIT, element.compilationUnit);
     encoder.setElement(Key.LIBRARY_DEPENDENCY, element.exportedLibrary);
     // TODO(johnniwinther): What is the base for the URI?
     encoder.setUri(Key.URI, element.uri, element.uri);
   }
 }
 
 class PrefixSerializer implements ElementSerializer {
   const PrefixSerializer();
@@ skipping 97 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}.");
   }
 }