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

pkg/front_end/lib/src/fasta/builder/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.class_builder;
 
 import '../errors.dart' show internalError;
 
 import 'builder.dart'
     show
         Builder,
         ConstructorReferenceBuilder,
         LibraryBuilder,
         MemberBuilder,
         MetadataBuilder,
         MixinApplicationBuilder,
         NamedTypeBuilder,
+        Scope,
+        ScopeBuilder,
         TypeBuilder,
         TypeDeclarationBuilder,
         TypeVariableBuilder;
 
-import '../scope.dart' show AccessErrorBuilder, AmbiguousBuilder, Scope;
-
 abstract class ClassBuilder<T extends TypeBuilder, R>
     extends TypeDeclarationBuilder<T, R> {
   final List<TypeVariableBuilder> typeVariables;
 
   T supertype;
 
   List<T> interfaces;
 
-  final Map<String, Builder> members;
+  final Scope scope;
+
+  final Scope constructors;
+
+  final ScopeBuilder scopeBuilder;
+
+  final ScopeBuilder constructorScopeBuilder;
 
   ClassBuilder(
       List<MetadataBuilder> metadata,
       int modifiers,
       String name,
       this.typeVariables,
       this.supertype,
       this.interfaces,
-      this.members,
+      this.scope,
+      this.constructors,
       LibraryBuilder parent,
       int charOffset)
-      : super(metadata, modifiers, name, parent, charOffset);
+      : scopeBuilder = new ScopeBuilder(scope),
+        constructorScopeBuilder = new ScopeBuilder(constructors),
+        super(metadata, modifiers, name, parent, charOffset);
 
   /// Returns true if this class is the result of applying a mixin to its
   /// superclass.
   bool get isMixinApplication => mixedInType != null;
 
   T get mixedInType;
 
   List<ConstructorReferenceBuilder> get constructorReferences => null;
 
-  Map<String, Builder> get constructors;
-
-  Map<String, Builder> get membersInScope => members;
-
   LibraryBuilder get library {
     LibraryBuilder library = parent;
     return library.partOfLibrary ?? library;
   }
 
   int resolveConstructors(LibraryBuilder library) {
     if (constructorReferences == null) return 0;
-    Scope scope = computeInstanceScope(library.scope);
     for (ConstructorReferenceBuilder ref in constructorReferences) {
       ref.resolveIn(scope);
     }
     return constructorReferences.length;
   }
 
-  Scope computeInstanceScope(Scope parent) {
-    if (typeVariables != null) {
-      Map<String, Builder> local = <String, Builder>{};
-      for (TypeVariableBuilder t in typeVariables) {
-        local[t.name] = t;
-      }
-      parent = new Scope(local, null, parent, isModifiable: false);
-    }
-    return new Scope(membersInScope, null, parent, isModifiable: false);
-  }
-
   /// Used to lookup a static member of this class.
   Builder findStaticBuilder(String name, int charOffset, Uri fileUri,
       {bool isSetter: false}) {
-    Builder builder = members[name];
-    if (builder?.next != null) {
-      Builder getterBuilder;
-      Builder setterBuilder;
-      Builder current = builder;
-      while (current != null) {
-        if (current.isGetter && getterBuilder == null) {
-          getterBuilder = current;
-        } else if (current.isSetter && setterBuilder == null) {
-          setterBuilder = current;
-        } else {
-          return new AmbiguousBuilder(name, builder, charOffset, fileUri);
-        }
-        current = current.next;
-      }
-      if (getterBuilder?.isInstanceMember ?? false) {
-        getterBuilder = null;
-      }
-      if (setterBuilder?.isInstanceMember ?? false) {
-        setterBuilder = null;
-      }
-      builder = isSetter ? setterBuilder : getterBuilder;
-      if (builder == null) {
-        if (isSetter && getterBuilder != null) {
-          return new AccessErrorBuilder(
-              name, getterBuilder, charOffset, fileUri);
-        } else if (!isSetter && setterBuilder != null) {
-          return new AccessErrorBuilder(
-              name, setterBuilder, charOffset, fileUri);
-        }
-      }
-    }
-    if (builder == null) {
-      return null;
-    } else if (isSetter && builder.isGetter) {
-      return null;
-    } else {
-      return builder.isInstanceMember ? null : builder;
-    }
+    Builder builder = isSetter
+        ? scope.lookupSetter(name, charOffset, fileUri, isInstanceScope: false)
+        : scope.lookup(name, charOffset, fileUri, isInstanceScope: false);
+    return builder;
   }
 
   Builder findConstructorOrFactory(String name, int charOffset, Uri uri) {
-    return constructors[name];
+    return constructors.lookup(name, charOffset, uri);
   }
 
   /// Returns a map which maps the type variables of [superclass] to their
   /// respective values as defined by the superclass clause of this class (and
   /// its superclasses).
   ///
   /// It's assumed that [superclass] is a superclass of this class.
   ///
   /// For example, given:
   ///
@@ skipping 46 matching lines @@
           }
           directSubstitutionMap[variables[i]] = argument;
         }
         substitutionMap = directSubstitutionMap;
       }
     }
     return substitutionMap;
   }
 
   void forEach(void f(String name, MemberBuilder builder)) {
-    members.forEach(f);
+    scope.forEach(f);
   }
 
   /// Don't use for scope lookup. Only use when an element is known to exist
   /// (and not a setter).
   MemberBuilder operator [](String name) {
-    return members[name] ?? internalError("Not found: '$name'.");
+    return scope.local[name] ?? internalError("Not found: '$name'.");
   }
 
   void addCompileTimeError(int charOffset, String message) {
     library.addCompileTimeError(charOffset, message, fileUri: fileUri);
   }
 
   void addWarning(int charOffset, String message) {
     library.addWarning(charOffset, message, fileUri: fileUri);
   }
 
   void addNit(int charOffset, String message) {
     library.addNit(charOffset, message, fileUri: fileUri);
   }
 }