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 66 matching lines @@
     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);
+    exports.add(new Export(
+        this,
+        loader.read(resolve(uri), charOffset, accessor: this),

[Siggi Cherem (dart-lang), 2017/07/26 19:22:42]

rather than rereading it here, store it in a local variable instead.

LibraryBuilder exportedLibrary = loader.read(...);
exportedLibrary.addExporter(this, combinators, charOffset);
exports.add(new Export(this, exportedLibrary, combinators, charset));

[scheglov, 2017/07/26 19:33:04]

Done.

+        combinators,
+        charOffset));
   }
 
   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);
   }
 }