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

pkg/front_end/lib/src/fasta/kernel/body_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.body_builder;
 
 import '../fasta_codes.dart'
     show FastaMessage, codeExpectedButGot, codeExpectedFunctionBody;
 
 import '../parser/parser.dart' show FormalParameterType, optional;
@@ skipping 702 matching lines @@
   @override
   void handleIdentifier(Token token, IdentifierContext context) {
     debugEvent("handleIdentifier");
     String name = token.lexeme;
     if (context.isScopeReference) {
       assert(!inInitializer ||
           this.scope == enclosingScope ||
           this.scope.parent == enclosingScope);
       // This deals with this kind of initializer: `C(a) : a = a;`
       Scope scope = inInitializer ? enclosingScope : this.scope;
-      Builder builder = scope.lookup(name, token.charOffset, uri);
-      push(builderToFirstExpression(builder, name, token.charOffset));
+      push(scopeLookup(scope, name, token.charOffset));
       return;
     } else if (context.inDeclaration) {
       if (context == IdentifierContext.topLevelVariableDeclaration ||
           context == IdentifierContext.fieldDeclaration) {
         constantExpressionRequired = member.isConst;
       }
     } else if (constantExpressionRequired &&
         !context.allowedInConstantExpression) {
       addCompileTimeError(
           token.charOffset, "Not a constant expression: $context");
     }
     push(new Identifier(name)..fileOffset = token.charOffset);
   }
 
+  /// Look up [name] in [scope] using [charOffset] to report any
+  /// problems. [isQualified] should be true if [name] is a qualified access
+  /// (which implies that it shouldn't be turned into a [ThisPropertyAccessor]
+  /// if the name doesn't resolve in the scope).
   @override
-  builderToFirstExpression(Builder builder, String name, int charOffset,
-      {bool isPrefix: false}) {
+  scopeLookup(Scope scope, String name, int charOffset,
+      {bool isQualified: false}) {
+    Builder builder = scope.lookup(name, charOffset, uri);
     if (builder == null || (!isInstanceContext && builder.isInstanceMember)) {
       Name n = new Name(name, library.library);
-      if (!isPrefix && isInstanceContext) {
+      if (!isQualified && isInstanceContext) {
         assert(builder == null);
         if (constantExpressionRequired) {
           addCompileTimeError(charOffset, "Not a constant expression.");
         }
         return new ThisPropertyAccessor(this, charOffset, n, null, null);
       } else if (isDartLibrary &&
           name == "main" &&
           library.uri.path == "_builtin" &&
           member?.name == "_getMainClosure") {
         // TODO(ahe): https://github.com/dart-lang/sdk/issues/28989
@@ skipping 15 matching lines @@
       if (constantExpressionRequired) {
         addCompileTimeError(charOffset, "Not a constant expression.");
       }
       return new ThisPropertyAccessor(
           this, charOffset, new Name(name, library.library), null, null);
     } else if (builder.isRegularMethod) {
       assert(builder.isStatic || builder.isTopLevel);
       return new StaticAccessor(this, charOffset, builder.target, null);
     } else if (builder is PrefixBuilder) {
       return builder;
-    } else if (builder is MixedAccessor) {
-      if (constantExpressionRequired && !builder.getter.target.isConst) {
-        addCompileTimeError(charOffset, "Not a constant expression.");
-      }
-      return new StaticAccessor(
-          this, charOffset, builder.getter.target, builder.setter.target);
     } else {
       if (builder.hasProblem && builder is! AccessErrorBuilder) return builder;
       Builder setter;
       if (builder.isSetter) {
         setter = builder;
       } else if (builder.isGetter) {
         setter = scope.lookupSetter(name, charOffset, uri);
       } else if (builder.isField && !builder.isFinal) {
         setter = builder;
       }
@@ skipping 475 matching lines @@
       if (suffix is Identifier) {
         suffix = suffix.name;
       }
       Builder builder;
       if (prefix is Builder) {
         builder = prefix;
       } else {
         builder = scope.lookup(prefix, beginToken.charOffset, uri);
       }
       if (builder is PrefixBuilder) {
-        name = builderToFirstExpression(
-            builder.exports[suffix], suffix, beginToken.charOffset,
-            isPrefix: true);
+        name = scopeLookup(builder.exports, suffix, beginToken.charOffset,
+            isQualified: true);
       } else {
         push(const DynamicType());
         addCompileTimeError(beginToken.charOffset,
             "Can't be used as a type: '${debugName(prefix, suffix)}'.");
         return;
       }
     }
     if (name is Identifier) {
       name = name.name;
     }
@@ skipping 355 matching lines @@
     // ClassBuilder, or a ThisPropertyAccessor. Otherwise, it's an error that
     // should be handled later.
     Identifier suffix = popIfNotNull(periodBeforeName);
     Identifier identifier;
     List<DartType> typeArguments = pop();
     dynamic type = pop();
     if (type is List) {
       var prefix = type[0];
       identifier = type[1];
       if (prefix is PrefixBuilder) {
-        // TODO(ahe): Handle privacy in prefix.exports.
-        type = builderToFirstExpression(
-            prefix.exports[identifier.name], identifier.name, start.charOffset);
+        type = scopeLookup(prefix.exports, identifier.name, start.charOffset,
+            isQualified: true);
         identifier = null;
       } else if (prefix is ClassBuilder) {
         type = prefix;
       } else {
         type = new Identifier(start.lexeme)..fileOffset = start.charOffset;
       }
     }
     String name;
     if (identifier != null && suffix != null) {
       name = "${identifier.name}.${suffix.name}";
@@ skipping 1227 matching lines @@
   } else if (node is PrefixBuilder) {
     return node.name;
   } else if (node is ThisAccessor) {
     return node.isSuper ? "super" : "this";
   } else if (node is FastaAccessor) {
     return node.plainNameForRead;
   } else {
     return internalError("Unhandled: ${node.runtimeType}");
   }
 }