Add export dependencies to Kernel libraries and use them to resynthesize ExportElement(s) in Analyz…

pkg/front_end/lib/src/fasta/source/source_library_builder.dart

 // 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.
 
 library fasta.source_library_builder;
 
 import 'package:kernel/ast.dart' show ProcedureKind;
 
 import '../../base/resolve_relative_uri.dart' show resolveRelativeUri;
 
@@ skipping 50 matching lines @@
 
   final DeclarationBuilder<T> libraryDeclaration;
 
   final List<ConstructorReferenceBuilder> constructorReferences =
       <ConstructorReferenceBuilder>[];
 
   final List<SourceLibraryBuilder<T, R>> parts = <SourceLibraryBuilder<T, R>>[];
 
   final List<Import> imports = <Import>[];
 
+  final List<Export> exports = <Export>[];
+
   final Scope importScope;
 
   final Uri fileUri;
 
   final List<List> implementationBuilders = <List<List>>[];
 
   /// Indicates whether type inference (and type promotion) should be disabled
   /// for this library.
   final bool disableTypeInference;
 
@@ skipping 63 matching lines @@
         "${name} != ${currentDeclaration.name}");
     DeclarationBuilder<T> previous = currentDeclaration;
     currentDeclaration = currentDeclaration.parent;
     return previous;
   }
 
   Uri resolve(String path) => uri.resolve(path);
 
   void addExport(List<MetadataBuilder> metadata, String uri,
       Unhandled conditionalUris, List<Combinator> combinators, int charOffset) {
-    loader
-        .read(resolve(uri), charOffset, accessor: this)
-        .addExporter(this, combinators, charOffset);
+    var exportedLibrary = loader.read(resolve(uri), charOffset, accessor: this);

[ahe, 2017/08/08 09:47:58]

Missing type.

[scheglov, 2017/08/08 16:31:16]

It's not like it is worse typed now than it was. There is no semantic or
cognitive difference between extracting a local variable with "var" or keeping
the expression inlined.

Also, the type is quite cumbersome "LibraryBuilder<TypeBuilder, dynamic>".

+    exportedLibrary.addExporter(this, combinators, charOffset);
+    exports.add(new Export(this, exportedLibrary, combinators, charOffset));

[ahe, 2017/08/08 09:47:58]

Question: you need access to the metadata as well, right?

[scheglov, 2017/08/08 16:31:16]

Yes, we need metadata for everything about what the specification says that it
has metadata, including all directives.

   }
 
   void addImport(
       List<MetadataBuilder> metadata,
       String uri,
       Unhandled conditionalUris,
       String prefix,
       List<Combinator> combinators,
       bool deferred,
       int charOffset,
@@ skipping 163 matching lines @@
         addCompileTimeError(
             templateDeferredPrefixDuplicated.withArguments(name),
             deferred.charOffset,
             fileUri);
         addCompileTimeError(
             templateDeferredPrefixDuplicatedCause.withArguments(name),
             other.charOffset,
             fileUri);
       }
       return existing
-        ..exports.merge(builder.exports,
+        ..exportScope.merge(builder.exportScope,
             (String name, Builder existing, Builder member) {
           return buildAmbiguousBuilder(name, existing, member, charOffset);
         });
     } else if (isDuplicatedDefinition(existing, builder)) {
       addCompileTimeError(templateDuplicatedDefinition.withArguments(name),
           charOffset, fileUri);
     }
     return members[name] = builder;
   }
 
@@ skipping 140 matching lines @@
 
   void addImportsToScope() {
     bool explicitCoreImport = this == loader.coreLibrary;
     for (Import import in imports) {
       if (import.imported == loader.coreLibrary) {
         explicitCoreImport = true;
       }
       import.finalizeImports(this);
     }
     if (!explicitCoreImport) {
-      loader.coreLibrary.exports.forEach((String name, Builder member) {
+      loader.coreLibrary.exportScope.forEach((String name, Builder member) {
         addToScope(name, member, -1, true);
       });
     }
   }
 
   @override
   void addToScope(String name, Builder member, int charOffset, bool isImport) {
     Map<String, Builder> map =
         member.isSetter ? importScope.setters : importScope.local;
     Builder existing = map[name];
@@ skipping 135 matching lines @@
   /// synthesize type variables on the factory matching the class'.
   void addFactoryDeclaration(
       ProcedureBuilder procedure, DeclarationBuilder<T> factoryDeclaration) {
     factoryDeclarations[procedure] = factoryDeclaration;
   }
 
   Scope toScope(Scope parent) {
     return new Scope(members, setters, parent, isModifiable: false);
   }
 }