Create separate scopes for constructors, setters, and other members.

pkg/front_end/lib/src/fasta/kernel/kernel_class_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.kernel_class_builder;
 
 import 'package:kernel/ast.dart'
     show
         Class,
         Constructor,
@@ skipping 24 matching lines @@
 
 import 'kernel_builder.dart'
     show
         Builder,
         ClassBuilder,
         ConstructorReferenceBuilder,
         KernelLibraryBuilder,
         KernelProcedureBuilder,
         KernelTypeBuilder,
         LibraryBuilder,
+        MemberBuilder,
         MetadataBuilder,
         ProcedureBuilder,
+        Scope,
         TypeVariableBuilder,
         computeDefaultTypeArguments;
 
 import 'redirecting_factory_body.dart' show RedirectingFactoryBody;
 
 abstract class KernelClassBuilder
     extends ClassBuilder<KernelTypeBuilder, InterfaceType> {
   KernelClassBuilder(
       List<MetadataBuilder> metadata,
       int modifiers,
       String name,
       List<TypeVariableBuilder> typeVariables,
       KernelTypeBuilder supertype,
       List<KernelTypeBuilder> interfaces,
-      Map<String, Builder> members,
+      Scope scope,
+      Scope constructors,
       LibraryBuilder parent,
       int charOffset)
       : super(metadata, modifiers, name, typeVariables, supertype, interfaces,
-            members, parent, charOffset);
+            scope, constructors, parent, charOffset);
 
   Class get cls;
 
   Class get target => cls;
 
   /// [arguments] have already been built.
   InterfaceType buildTypesWithBuiltArguments(
       LibraryBuilder library, List<DartType> arguments) {
     assert(arguments == null || cls.typeParameters.length == arguments.length);
     return arguments == null ? cls.rawType : new InterfaceType(cls, arguments);
@@ skipping 28 matching lines @@
       return new Supertype(cls, buildTypeArguments(library, arguments));
     } else {
       return cls.asRawSupertype;
     }
   }
 
   @override
   int resolveConstructors(LibraryBuilder library) {
     int count = super.resolveConstructors(library);
     if (count != 0) {
+      Map<String, MemberBuilder> constructors = this.constructors.local;
       // Copy keys to avoid concurrent modification error.
-      List<String> names = members.keys.toList();
+      List<String> names = constructors.keys.toList();
       for (String name in names) {
-        Builder builder = members[name];
+        Builder builder = constructors[name];
         if (builder is KernelProcedureBuilder && builder.isFactory) {
           // Compute the immediate redirection target, not the effective.
           ConstructorReferenceBuilder redirectionTarget =
               builder.redirectionTarget;
           if (redirectionTarget != null) {
             assert(builder.actualBody == null);
             Builder targetBuilder = redirectionTarget.target;
             addRedirectingConstructor(builder, library);
             if (targetBuilder is ProcedureBuilder) {
               Member target = targetBuilder.target;
@@ skipping 24 matching lines @@
     //
     // The synthetic field looks like this:
     //
     //     final _redirecting# = [c1, ..., cn];
     //
     // Where each c1 ... cn are an instance of [StaticGet] whose target is
     // [constructor.target].
     //
     // TODO(ahe): Generate the correct factory body instead.
     DillMemberBuilder constructorsField =
-        members.putIfAbsent("_redirecting#", () {
+        scope.local.putIfAbsent("_redirecting#", () {
       ListLiteral literal = new ListLiteral(<Expression>[]);
       Name name = new Name("_redirecting#", library.library);
       Field field = new Field(name,
           isStatic: true, initializer: literal, fileUri: cls.fileUri)
         ..fileOffset = cls.fileOffset;
       cls.addMember(field);
       return new DillMemberBuilder(field, this);
     });
     Field field = constructorsField.target;
     ListLiteral literal = field.initializer;
@@ skipping 89 matching lines @@
               "The method '$name::${declaredMember.name.name}' doesn't have "
               "the named parameter '${interfaceNamedParameters.current.name}' "
               "of overriden method '${interfaceMember.enclosingClass.name}::"
               "${interfaceMember.name.name}'.");
           break outer;
         }
       }
     }
   }
 }