Prepare for separate setter scope.

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 AsyncMarker, ProcedureKind;
 
 import '../combinator.dart' show Combinator;
 
@@ skipping 32 matching lines @@
 
   final List<ConstructorReferenceBuilder> constructorReferences =
       <ConstructorReferenceBuilder>[];
 
   final List<SourceLibraryBuilder<T, R>> parts = <SourceLibraryBuilder<T, R>>[];
 
   final List<Import> imports = <Import>[];
 
   final Map<String, Builder> exports = <String, Builder>{};
 
-  final Scope scope = new Scope(<String, Builder>{}, null, isModifiable: false);
+  final Scope scope = new Scope.top();
 
   final Uri fileUri;
 
   final List<List> implementationBuilders = <List<List>>[];
 
   String name;
 
   String partOfName;
 
   Uri partOfUri;
@@ skipping 232 matching lines @@
       // extends Object with Mixin {}` in the same library.
       return !existing.isMixinApplication || !other.isMixinApplication;
     }
     return true;
   }
 
   void buildBuilder(Builder builder);
 
   R build() {
     assert(implementationBuilders.isEmpty);
-    members.forEach((String name, Builder builder) {
+    forEach((String name, Builder builder) {
       do {
         buildBuilder(builder);
         builder = builder.next;
       } while (builder != null);
     });
     for (List list in implementationBuilders) {
       String name = list[0];
       Builder builder = list[1];
       int charOffset = list[2];
       addBuilder(name, builder, charOffset);
@@ skipping 45 matching lines @@
       if (part.partOfName != name && part.partOfUri != uri) {
         String partName = part.partOfName ?? "${part.partOfUri}";
         String myName = name == null ? "'$uri'" : "'${name}' ($uri)";
         addWarning(
             -1,
             "Using '${part.fileUri}' as part of '$myName' but it's 'part of'"
             " declaration says '$partName'.");
         // The part is still included.
       }
     }
-    part.members.forEach((String name, Builder builder) {
+    part.forEach((String name, Builder builder) {
       if (builder.next != null) {
         assert(builder.next.next == null);
         addBuilder(name, builder.next, builder.next.charOffset);
       }
       addBuilder(name, builder, builder.charOffset);
     });
     types.addAll(part.types);
     constructorReferences.addAll(part.constructorReferences);
     part.partOfLibrary = this;
     // TODO(ahe): Include metadata from part?
   }
 
   void buildInitialScopes() {
-    members.forEach(addToExportScope);
-    members.forEach((String name, Builder member) {
+    forEach(addToExportScope);
+    forEach((String name, Builder member) {
       addToScope(name, member, member.charOffset, false);
     });
   }
 
   void addImportsToScope() {
     bool explicitCoreImport = this == loader.coreLibrary;
     for (Import import in imports) {
       if (import.imported == loader.coreLibrary) {
         explicitCoreImport = true;
       }
@@ skipping 35 matching lines @@
       exports[name] = member;
     }
     return true;
   }
 
   int resolveTypes(_) {
     int typeCount = types.length;
     for (T t in types) {
       t.resolveIn(scope);
     }
-    members.forEach((String name, Builder member) {
+    forEach((String name, Builder member) {
       typeCount += member.resolveTypes(this);
     });
     return typeCount;
   }
 
   int resolveConstructors(_) {
     int count = 0;
-    members.forEach((String name, Builder member) {
+    forEach((String name, Builder member) {
       count += member.resolveConstructors(this);
     });
     return count;
   }
 
   List<TypeVariableBuilder> copyTypeVariables(
       List<TypeVariableBuilder> original);
 
   @override
   String get fullNameForErrors => name ?? "<library '$relativeFileUri'>";
@@ skipping 75 matching lines @@
   }
 
   /// Called to register [procedure] as a factory whose types are collected in
   /// [factoryDeclaration]. Later, once the class has been built, we can
   /// synthesize type variables on the factory matching the class'.
   void addFactoryDeclaration(
       ProcedureBuilder procedure, DeclarationBuilder<T> factoryDeclaration) {
     factoryDeclarations[procedure] = factoryDeclaration;
   }
 }