Support multiple resolution inputs from command line.

pkg/compiler/lib/src/serialization/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;
 
-import '../elements/elements.dart';
+import '../common.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
+import '../elements/elements.dart';
 import '../util/enumset.dart';
 
 import 'constant_serialization.dart';
 import 'element_serialization.dart';
 import 'json_serializer.dart';
 import 'keys.dart';
 import 'type_serialization.dart';
 import 'values.dart';
 
 export 'task.dart' show LibraryDeserializer;
@@ skipping 659 matching lines @@
   /// encoding the [ObjectValue] for [element] is put into the work queue of
   /// this serializer.
   Value _getElementId(Element element) {
     if (element == null) {
       throw new ArgumentError('Serializer._getElementDataObject(null)');
     }
     element = element.declaration;
     DataObject dataObject = _elementMap[element];
     if (dataObject == null) {
       if (!shouldInclude(element)) {
+
+        /// Helper used to check that external references are serialized by
+        /// the right kind.
+        bool verifyElement(var found, var expected) {
+          found = found.declaration;
+          if (found == expected) return true;
+          if (found.isAbstractField && expected.isGetter) {
+            return found.getter == expected;
+          }
+          if (found.isAbstractField && expected.isSetter) {
+            return found.setter == expected;
+          }
+          return false;
+        }
+
         if (element.isLibrary) {
           LibraryElement library = element;
           _elementMap[element] = dataObject = new DataObject(
               new IntValue(_elementMap.length),
               new EnumValue(SerializedElementKind.EXTERNAL_LIBRARY));
           ObjectEncoder encoder = new ObjectEncoder(this, dataObject.map);
           encoder.setUri(Key.URI, library.canonicalUri, library.canonicalUri);
-        } else if (element.isStatic) {
-          Value classId = _getElementId(element.enclosingClass);
-          _elementMap[element] = dataObject = new DataObject(
-              new IntValue(_elementMap.length),
-              new EnumValue(SerializedElementKind.EXTERNAL_STATIC_MEMBER));
-          ObjectEncoder encoder = new ObjectEncoder(this, dataObject.map);
-          encoder.setValue(Key.CLASS, classId);
-          encoder.setString(Key.NAME, element.name);
         } else if (element.isConstructor) {
+          assert(invariant(element,
+              verifyElement(
+                  element.enclosingClass.implementation.lookupConstructor(
+                      element.name),
+                  element),
+              message: "Element $element is not found as a "
+                  "constructor of ${element.enclosingClass.implementation}."));
           Value classId = _getElementId(element.enclosingClass);
           _elementMap[element] = dataObject = new DataObject(
               new IntValue(_elementMap.length),
               new EnumValue(SerializedElementKind.EXTERNAL_CONSTRUCTOR));
           ObjectEncoder encoder = new ObjectEncoder(this, dataObject.map);
           encoder.setValue(Key.CLASS, classId);
           encoder.setString(Key.NAME, element.name);
+        } else if (element.isClassMember) {
+          assert(invariant(element,
+              verifyElement(
+                  element.enclosingClass.lookupLocalMember(element.name),
+                  element),
+              message: "Element $element is not found as a "
+                  "class member of ${element.enclosingClass}."));
+          Value classId = _getElementId(element.enclosingClass);
+          _elementMap[element] = dataObject = new DataObject(
+              new IntValue(_elementMap.length),
+              new EnumValue(SerializedElementKind.EXTERNAL_CLASS_MEMBER));
+          ObjectEncoder encoder = new ObjectEncoder(this, dataObject.map);
+          encoder.setValue(Key.CLASS, classId);
+          encoder.setString(Key.NAME, element.name);
+          if (element.isAccessor) {
+            encoder.setBool(Key.GETTER, element.isGetter);
+          }
         } else {
+          assert(invariant(element,
+              verifyElement(
+                  element.library.implementation.find(element.name), element),
+              message: "Element $element is not found as a "
+                  "library member of ${element.library.implementation}."));
           Value libraryId = _getElementId(element.library);
           _elementMap[element] = dataObject = new DataObject(
               new IntValue(_elementMap.length),
               new EnumValue(SerializedElementKind.EXTERNAL_LIBRARY_MEMBER));
           ObjectEncoder encoder = new ObjectEncoder(this, dataObject.map);
           encoder.setValue(Key.LIBRARY, libraryId);
           encoder.setString(Key.NAME, element.name);
+          if (element.isAccessor) {

[Siggi Cherem (dart-lang), 2016/05/24 18:08:15]

are the changes about Key.GETTER needed for supporting the multiple input files?
or is this unrelated? If so, can we split those changes in a separate CL (seems
like most changes above this line and a few further down)?

[Johnni Winther, 2016/05/25 07:54:46]

These are needed. It turned out that because of the missing `shouldInclude`
argument to [Serializer] in library_test.dart we always had an internal version
of the referenced getters and setters.

With the correct split (and enforced disjointness) we now (for the first time)
need external references to getters and setters. Since we lookup by name only
(in the [find] and [lookupLocalMember] methods) we need to the extra bit to
access the right child of the [AbstractFieldElement].

+            encoder.setBool(Key.GETTER, element.isGetter);
+          }
         }
       } else {
         // Run through [ELEMENT_SERIALIZERS] sequentially to find the one that
         // deals with [element].
         for (ElementSerializer serializer in ELEMENT_SERIALIZERS) {
           SerializedElementKind kind = serializer.getSerializedKind(element);
           if (kind != null) {
             _elementMap[element] = dataObject = new DataObject(
                 new IntValue(_elementMap.length), new EnumValue(kind));
             // Delay the serialization of the element itself to avoid loops, and
@@ skipping 141 matching lines @@
   /// Use [getDecoder] to retrieve the data object with id [tag] stored for
   /// [element]. If not object is stored for [tag], [getDecoder] returns `null`.
   void onElement(Element element, ObjectDecoder getDecoder(String tag)) {}
 
   /// Called to deserialize custom data from [decoder].
   dynamic onData(ObjectDecoder decoder) {}
 }
 
 /// Context for parallel deserialization.
 class DeserializationContext {
+  final DiagnosticReporter reporter;
   Map<Uri, LibraryElement> _uriMap = <Uri, LibraryElement>{};
   List<Deserializer> deserializers = <Deserializer>[];
   List<DeserializerPlugin> plugins = <DeserializerPlugin>[];
 
+  DeserializationContext(this.reporter);
+
   LibraryElement lookupLibrary(Uri uri) {
     return _uriMap.putIfAbsent(uri, () {
+      Uri foundUri;
+      LibraryElement foundLibrary;
       for (Deserializer deserializer in deserializers) {
         LibraryElement library = deserializer.lookupLibrary(uri);
         if (library != null) {
-          return library;
+          if (foundLibrary != null) {
+            reporter.reportErrorMessage(NO_LOCATION_SPANNABLE,
+                MessageKind.DUPLICATE_SERIALIZED_LIBRARY,
+                {'libraryUri': uri, 'sourceUri1': foundUri, 'sourceUri2': deserializer.sourceUri});

[Siggi Cherem (dart-lang), 2016/05/24 18:08:15]

dartfmt

[Johnni Winther, 2016/05/25 07:54:46]

Done.

+          }
+          foundUri = deserializer.sourceUri;
+          foundLibrary = library;
         }
       }
-      return null;
+      return foundLibrary;
     });
   }
 }
 
 /// Deserializer for a closed collection of libraries.
 // TODO(johnniwinther): Support per-library deserialization and dependencies
 // between deserialized subcomponent.
 class Deserializer {
   final DeserializationContext context;
   final SerializationDecoder decoder;
+  final Uri sourceUri;
   ObjectDecoder _headerObject;
   ListDecoder _elementList;
   ListDecoder _typeList;
   ListDecoder _constantList;
   Map<int, Element> _elementMap = {};
   Map<int, DartType> _typeMap = {};
   Map<int, ConstantExpression> _constantMap = {};
 
-  Deserializer.fromText(this.context, String text, this.decoder) {
+  Deserializer.fromText(
+      this.context, this.sourceUri, String text, this.decoder) {
     _headerObject = new ObjectDecoder(this, decoder.decode(text));
   }
 
   /// Returns the [ListDecoder] for the [Element]s in this deserializer.
   ListDecoder get elements {
     if (_elementList == null) {
       _elementList = _headerObject.getList(Key.ELEMENTS);
     }
     return _elementList;
   }
@@ skipping 43 matching lines @@
           decoder.getEnum(Key.KIND, SerializedElementKind.values);
       if (elementKind == SerializedElementKind.EXTERNAL_LIBRARY) {
         Uri uri = decoder.getUri(Key.URI);
         element = context.lookupLibrary(uri);
         if (element == null) {
           throw new StateError("Missing library for $uri.");
         }
       } else if (elementKind == SerializedElementKind.EXTERNAL_LIBRARY_MEMBER) {
         LibraryElement library = decoder.getElement(Key.LIBRARY);
         String name = decoder.getString(Key.NAME);
+        bool isGetter = decoder.getBool(Key.GETTER, isOptional: true);
         element = library.find(name);
         if (element == null) {
           throw new StateError("Missing library member for $name in $library.");
         }
-      } else if (elementKind == SerializedElementKind.EXTERNAL_STATIC_MEMBER) {
+        if (isGetter != null) {
+          AbstractFieldElement abstractField = element;
+          element = isGetter ? abstractField.getter : abstractField.setter;
+          if (element == null) {
+            throw new StateError(
+                "Missing ${isGetter ? 'getter' : 'setter'} for "
+                    "$name in $library.");
+          }
+        }
+      } else if (elementKind == SerializedElementKind.EXTERNAL_CLASS_MEMBER) {
         ClassElement cls = decoder.getElement(Key.CLASS);
         String name = decoder.getString(Key.NAME);
+        bool isGetter = decoder.getBool(Key.GETTER, isOptional: true);
         element = cls.lookupLocalMember(name);
         if (element == null) {
-          throw new StateError("Missing static member for $name in $cls.");
+          throw new StateError("Missing class member for $name in $cls.");
+        }
+        if (isGetter != null) {
+          AbstractFieldElement abstractField = element;
+          element = isGetter ? abstractField.getter : abstractField.setter;
+          if (element == null) {
+            throw new StateError(
+                "Missing ${isGetter ? 'getter' : 'setter'} for $name in $cls.");
+          }
         }
       } else if (elementKind == SerializedElementKind.EXTERNAL_CONSTRUCTOR) {
         ClassElement cls = decoder.getElement(Key.CLASS);
         String name = decoder.getString(Key.NAME);
         element = cls.lookupConstructor(name);
         if (element == null) {
           throw new StateError("Missing constructor for $name in $cls.");
         }
       } else {
         element = ElementDeserializer.deserialize(decoder, elementKind);
@@ skipping 43 matching lines @@
 
   /// Returns the value used to store [key] as a property in the encoding an
   /// [ObjectValue].
   ///
   /// Different encodings have different restrictions and capabilities as how
   /// to store a [Key] value. For instance: A JSON encoding needs to convert
   /// [Key] to a [String] to store it in a JSON object; a Dart encoding can
   /// choose to store a [Key] as an [int] or as the [Key] itself.
   getObjectPropertyValue(Key key);
 }