Prepare for separate setter scope.

pkg/front_end/lib/src/fasta/kernel/kernel_target.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.kernel_target;
 
 import 'dart:async' show Future;
 
 import 'dart:io' show File, IOSink;
 
@@ skipping 157 matching lines @@
     if (cls.interfaces != null) {
       for (NamedTypeBuilder t in cls.interfaces) {
         add(t);
       }
     }
   }
 
   List<ClassBuilder> collectAllClasses() {
     List<ClassBuilder> result = <ClassBuilder>[];
     loader.builders.forEach((Uri uri, LibraryBuilder library) {
-      library.members.forEach((String name, Builder member) {
+      library.forEach((String name, Builder member) {
         if (member is KernelClassBuilder) {
           result.add(member);
         }
       });
       // TODO(ahe): Translate this if needed:
       // if (library is KernelLibraryBuilder) {
       //   result.addAll(library.mixinApplicationClasses);
       // }
     });
     return result;
   }
 
   List<SourceClassBuilder> collectAllSourceClasses() {
     List<SourceClassBuilder> result = <SourceClassBuilder>[];
     loader.builders.forEach((Uri uri, LibraryBuilder library) {
-      library.members.forEach((String name, Builder member) {
+      library.forEach((String name, Builder member) {
         if (member is SourceClassBuilder) {
           result.add(member);
         }
       });
     });
     return result;
   }
 
   void breakCycle(ClassBuilder builder) {
     Class cls = builder.target;
@@ skipping 18 matching lines @@
         ? new Future<Program>.value(program)
         : writeLinkedProgram(uri, program, isFullProgram: isFullProgram);
   }
 
   Future<Program> writeOutline(Uri uri) async {
     if (loader.first == null) return null;
     try {
       await loader.buildOutlines();
       loader.coreLibrary
           .becomeCoreLibrary(const DynamicType(), const VoidType());
-      dynamicType.bind(loader.coreLibrary.members["dynamic"]);
+      dynamicType.bind(loader.coreLibrary["dynamic"]);
       loader.resolveParts();
       loader.computeLibraryScopes();
       loader.resolveTypes();
       loader.buildProgram();
       loader.checkSemantics();
       List<SourceClassBuilder> sourceClasses = collectAllSourceClasses();
       installDefaultSupertypes();
       installDefaultConstructors(sourceClasses);
       loader.resolveConstructors();
       loader.finishTypeVariables(objectClassBuilder);
@@ skipping 106 matching lines @@
       libraries.addAll(binary.libraries);
       uriToSource.addAll(binary.uriToSource);
     }
 
     // TODO(ahe): Remove this line. Kernel seems to generate a default line map
     // that used when there's no fileUri on an element. Instead, ensure all
     // elements have a fileUri.
     uriToSource[""] = new Source(<int>[0], const <int>[]);
     Program program = new Program(libraries, uriToSource);
     if (loader.first != null) {
-      Builder builder = loader.first.members["main"];
+      Builder builder = loader.first.lookup("main", -1, null);
       if (builder is KernelProcedureBuilder) {
         program.mainMethod = builder.procedure;
       }
     }
     if (errors.isEmpty || dillTarget.isLoaded) {
       setup_builtin_library.transformProgram(program);
     }
     ticker.logMs("Linked program");
     return program;
   }
@@ skipping 12 matching lines @@
       ticker.logMs("Wrote program to ${uri.toFilePath()}");
     } else {
       ticker.logMs("Wrote outline to ${uri.toFilePath()}");
     }
     return null;
   }
 
   void installDefaultSupertypes() {
     Class objectClass = this.objectClass;
     loader.builders.forEach((Uri uri, LibraryBuilder library) {
-      library.members.forEach((String name, Builder builder) {
+      library.forEach((String name, Builder builder) {
         if (builder is SourceClassBuilder) {
           Class cls = builder.target;
           if (cls != objectClass) {
             cls.supertype ??= objectClass.asRawSupertype;
           }
           if (builder.isMixinApplication) {
             cls.mixedInType = builder.mixedInType.buildSupertype(library);
           }
         }
       });
     });
     ticker.logMs("Installed Object as implicit superclass");
   }
 
   void installDefaultConstructors(List<SourceClassBuilder> builders) {
     Class objectClass = this.objectClass;
     for (SourceClassBuilder builder in builders) {
       if (builder.target != objectClass) {
         installDefaultConstructor(builder);
       }
     }
     ticker.logMs("Installed default constructors");
   }
 
-  KernelClassBuilder get objectClassBuilder {
-    return loader.coreLibrary.exports["Object"];
-  }
+  KernelClassBuilder get objectClassBuilder => loader.coreLibrary["Object"];
 
   Class get objectClass => objectClassBuilder.cls;
 
   /// If [builder] doesn't have a constructors, install the defaults.
   void installDefaultConstructor(SourceClassBuilder builder) {
     if (builder.cls.isMixinApplication) {
       // We have to test if builder.cls is a mixin application. [builder] may
       // think it's a mixin application, but if its mixed-in type couldn't be
       // resolved, the target class won't be a mixin application and we need
       // to add a default constructor to complete error recovery.
@@ skipping 267 matching lines @@
   }
   for (Constructor constructor in superclass.constructors) {
     if (constructor.name.name.isEmpty) {
       return constructor.function.requiredParameterCount == 0
           ? constructor
           : null;
     }
   }
   return null;
 }