Prepare for separate setter scope.

pkg/analyzer/lib/src/fasta/element_store.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.analyzer.element_store;
 
 import 'package:analyzer/src/kernel/loader.dart' show ReferenceLevelLoader;
 
 import 'package:kernel/ast.dart';
 
@@ skipping 57 matching lines @@
 
   factory ElementStoreImplementation(
       LibraryBuilder coreLibrary, Map<Uri, LibraryBuilder> libraries) {
     Map<Builder, Element> elements = <Builder, Element>{};
     libraries.forEach((Uri uri, LibraryBuilder library) {
       KernelCompilationUnitElement unit =
           new KernelCompilationUnitElement(library);
       KernelLibraryElement element = new KernelLibraryElement(unit);
       elements[library] = element;
       unit.library = element;
-      library.members.forEach((String name, Builder builder) {
+      library.forEach((String name, Builder builder) {
         do {
           if (builder is ClassBuilder) {
             elements[builder] = new KernelClassElement(builder);
           } else if (builder is DillMemberBuilder) {
             Member member = builder.member;
             if (member is Field) {} else if (member is Procedure) {
               buildDillFunctionElement(builder, unit, elements);
             } else {
               internalError("Unhandled $name ${member.runtimeType} in $uri");
             }
           } else if (builder is KernelProcedureBuilder) {
             buildKernelFunctionElement(builder, unit, elements);
           } else if (builder is BuiltinTypeBuilder) {
             // TODO(ahe): Set up elements for dynamic and void.
           } else {
             internalError("Unhandled $name ${builder.runtimeType} in $uri");
           }
           builder = builder.next;
         } while (builder != null);
       });
     });
     return new ElementStoreImplementation.internal(coreLibrary, elements);
   }
 
   bool get ignoreRedirectingFactories => false;
 
   Constructor getCoreClassConstructorReference(String className,
       {String constructorName, String library}) {
     assert(library == null);
-    KernelClassBuilder cls = coreLibrary.members[className];
-    Constructor constructor = constructorName == null
-        ? cls.cls.constructors.first
-        : cls.cls.constructors
-            .firstWhere((Constructor c) => c.name.name == constructorName);
-    return constructor;
+    return coreLibrary
+        .getConstructor(className, constructorName: constructorName)
+        .target;
   }
 
   Library getLibraryReference(LibraryElement element) {
     return internalError("not supported.");
   }
 
   Class getClassReference(covariant KernelClassElement cls) => cls.builder.cls;
 
   Member getMemberReference(Element element) {
     if (element is KernelFunctionElement) {
@@ skipping 168 matching lines @@
   }
 }
 
 class KernelInterfaceType extends MockInterfaceType {
   final KernelClassElement element;
 
   KernelInterfaceType(this.element);
 
   List<analyzer.DartType> get typeArguments => const <analyzer.DartType>[];
 }