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

pkg/front_end/lib/src/fasta/kernel/kernel_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.kernel_library_builder;
 
 import 'package:kernel/ast.dart';
 
 import 'package:kernel/clone.dart' show CloneVisitor;
 
@@ skipping 28 matching lines @@
         KernelFunctionTypeBuilder,
         KernelInvalidTypeBuilder,
         KernelMixinApplicationBuilder,
         KernelNamedMixinApplicationBuilder,
         KernelNamedTypeBuilder,
         KernelProcedureBuilder,
         KernelTypeBuilder,
         KernelTypeVariableBuilder,
         MemberBuilder,
         MetadataBuilder,
-        MixedAccessor,
         NamedMixinApplicationBuilder,
         PrefixBuilder,
         ProcedureBuilder,
+        Scope,
         TypeBuilder,
         TypeVariableBuilder,
         compareProcedures;
 
 class KernelLibraryBuilder
     extends SourceLibraryBuilder<KernelTypeBuilder, Library> {
   final Library library;
 
   final Map<String, SourceClassBuilder> mixinApplicationClasses =
       <String, SourceClassBuilder>{};
@@ skipping 33 matching lines @@
   void addClass(
       List<MetadataBuilder> metadata,
       int modifiers,
       String className,
       List<TypeVariableBuilder> typeVariables,
       KernelTypeBuilder supertype,
       List<KernelTypeBuilder> interfaces,
       int charOffset) {
     assert(currentDeclaration.parent == libraryDeclaration);
     Map<String, MemberBuilder> members = currentDeclaration.members;
+    Map<String, MemberBuilder> constructors = currentDeclaration.constructors;
+    Map<String, MemberBuilder> setters = currentDeclaration.setters;
+
+    Scope classScope = new Scope(
+        members, setters, scope.withTypeVariables(typeVariables),
+        isModifiable: false);
+
+    // When looking up a constructor, we don't consider type variables or the
+    // library scope.
+    Scope constructorScope =
+        new Scope(constructors, null, null, isModifiable: false);
     ClassBuilder cls = new SourceClassBuilder(
         metadata,
         modifiers,
         className,
         typeVariables,
         supertype,
         interfaces,
-        members,
+        classScope,
+        constructorScope,
         this,
         new List<ConstructorReferenceBuilder>.from(constructorReferences),
         charOffset);
     constructorReferences.clear();
-    members.forEach((String name, MemberBuilder builder) {
-      while (builder != null) {
-        builder.parent = cls;
-        builder = builder.next;
+    void setParent(String name, MemberBuilder member) {
+      while (member != null) {
+        member.parent = cls;
+        member = member.next;
       }
-    });
+    }
+
+    members.forEach(setParent);
+    constructors.forEach(setParent);
+    setters.forEach(setParent);
     // Nested declaration began in `OutlineBuilder.beginClassDeclaration`.
     endNestedDeclaration().resolveTypes(typeVariables, this);
     addBuilder(className, cls, charOffset);
   }
 
   void addNamedMixinApplication(
       List<MetadataBuilder> metadata,
       String name,
       List<TypeVariableBuilder> typeVariables,
       int modifiers,
@@ skipping 10 matching lines @@
 
   void addField(List<MetadataBuilder> metadata, int modifiers,
       KernelTypeBuilder type, String name, int charOffset) {
     addBuilder(
         name,
         new KernelFieldBuilder(
             metadata, type, name, modifiers, this, charOffset),
         charOffset);
   }
 
-  String computeConstructorName(String name) {
-    assert(isConstructorName(name, currentDeclaration.name));
+  String computeAndValidateConstructorName(String name, int charOffset) {
+    String className = currentDeclaration.name;
+    bool startsWithClassName = name.startsWith(className);
+    if (startsWithClassName && name.length == className.length) {
+      // Unnamed constructor or factory.
+      return "";
+    }
     int index = name.indexOf(".");
-    return index == -1 ? "" : name.substring(index + 1);
+    if (startsWithClassName && index == className.length) {
+      // Named constructor or factory.
+      return name.substring(index + 1);
+    }
+    if (index == -1) {
+      // A legal name.

[karlklose, 2017/04/03 08:05:37]

How about 'A legal name for a method, but not for a constructor name'?

[ahe, 2017/04/04 09:54:51]

Done.

+      return null;
+    }
+    String suffix = name.substring(index + 1);
+    addCompileTimeError(
+        charOffset,
+        "'$name' isn't a legal method name.\n"
+        "Did you mean '$className.$suffix'?");
+    return suffix;
   }
 
   void addProcedure(
       List<MetadataBuilder> metadata,
       int modifiers,
       KernelTypeBuilder returnType,
       String name,
       List<TypeVariableBuilder> typeVariables,
       List<FormalParameterBuilder> formals,
       AsyncMarker asyncModifier,
       ProcedureKind kind,
       int charOffset,
       int charOpenParenOffset,
       int charEndOffset,
       String nativeMethodName,
       {bool isTopLevel}) {
     // Nested declaration began in `OutlineBuilder.beginMethod` or
     // `OutlineBuilder.beginTopLevelMethod`.
     endNestedDeclaration().resolveTypes(typeVariables, this);
     ProcedureBuilder procedure;
-    if (!isTopLevel && isConstructorName(name, currentDeclaration.name)) {
-      name = computeConstructorName(name);
+    String constructorName =
+        isTopLevel ? null : computeAndValidateConstructorName(name, charOffset);
+    if (constructorName != null) {
+      name = constructorName;
       procedure = new KernelConstructorBuilder(
           metadata,
           modifiers & ~abstractMask,
           returnType,
           name,
           typeVariables,
           formals,
           this,
           charOffset,
           charOpenParenOffset,
@@ skipping 17 matching lines @@
     }
     addBuilder(name, procedure, charOffset);
     if (nativeMethodName != null) {
       addNativeMethod(procedure);
     }
   }
 
   void addFactoryMethod(
       List<MetadataBuilder> metadata,
       int modifiers,
-      ConstructorReferenceBuilder constructorName,
+      ConstructorReferenceBuilder constructorNameReference,
       List<FormalParameterBuilder> formals,
       AsyncMarker asyncModifier,
       ConstructorReferenceBuilder redirectionTarget,
       int charOffset,
       int charOpenParenOffset,
       int charEndOffset,
       String nativeMethodName) {
     // Nested declaration began in `OutlineBuilder.beginFactoryMethod`.
     DeclarationBuilder<KernelTypeBuilder> factoryDeclaration =
         endNestedDeclaration();
-    String name = constructorName.name;
-    if (isConstructorName(name, currentDeclaration.name)) {
-      name = computeConstructorName(name);
+    String name = constructorNameReference.name;
+    String constructorName =
+        computeAndValidateConstructorName(name, charOffset);
+    if (constructorName != null) {
+      name = constructorName;
     }
-    assert(constructorName.suffix == null);
+    assert(constructorNameReference.suffix == null);
     KernelProcedureBuilder procedure = new KernelProcedureBuilder(
         metadata,
         staticMask | modifiers,
         null,
         name,
         <TypeVariableBuilder>[],
         formals,
         asyncModifier,
         ProcedureKind.Factory,
         this,
@@ skipping 85 matching lines @@
     super.build();
     library.name = name;
     library.procedures.sort(compareProcedures);
     return library;
   }
 
   @override
   Builder buildAmbiguousBuilder(
       String name, Builder builder, Builder other, int charOffset,
       {bool isExport: false, bool isImport: false}) {
+    // TODO(ahe): Can I move this to Scope or Prefix?
     if (builder == other) return builder;
     if (builder is InvalidTypeBuilder) return builder;
     if (other is InvalidTypeBuilder) return other;
     if (builder is AccessErrorBuilder) {
       AccessErrorBuilder error = builder;
       builder = error.builder;
     }
     if (other is AccessErrorBuilder) {
       AccessErrorBuilder error = other;
       other = error.builder;
     }
     bool isLocal = false;
     Builder preferred;
     Uri uri;
     Uri otherUri;
     Uri preferredUri;
     Uri hiddenUri;
-    if (members[name] == builder) {
+    if (scope.local[name] == builder) {
       isLocal = true;
       preferred = builder;
       hiddenUri = other.computeLibraryUri();
     } else {
       uri = builder.computeLibraryUri();
       otherUri = other.computeLibraryUri();
       if (otherUri?.scheme == "dart" && uri?.scheme != "dart") {
         preferred = builder;
         preferredUri = uri;
         hiddenUri = otherUri;
@@ skipping 21 matching lines @@
         } else {
           addNit(
               charOffset,
               "Import of '$name' (from '${preferredUri}') hides import from "
               "'${hiddenUri}'.");
         }
       }
       return preferred;
     }
     if (builder.next == null && other.next == null) {
-      if (builder.isGetter && other.isSetter) {
-        return new MixedAccessor(builder, other, this);
-      } else if (builder.isSetter && other.isGetter) {
-        return new MixedAccessor(other, builder, this);
-      }
       if (isImport && builder is PrefixBuilder && other is PrefixBuilder) {
         // Handles the case where the same prefix is used for different
         // imports.
-        PrefixBuilder prefix = builder;
-        other.exports.forEach((String name, Builder member) {
-          Builder existing = exports[name];
-          if (existing != null) {
-            if (existing != member) {
-              member = buildAmbiguousBuilder(name, existing, member, charOffset,
-                  isExport: isExport, isImport: isImport);
-            }
-          }
-          prefix.exports[name] = member;
-        });
-        return builder;
+        return builder
+          ..exports.merge(other.exports,
+              (String name, Builder existing, Builder member) {
+            return buildAmbiguousBuilder(name, existing, member, charOffset,
+                isExport: isExport, isImport: isImport);
+          });
       }
     }
     if (isExport) {
       addNit(charOffset,
           "'$name' is exported from both '${uri}' and '${otherUri}'.");
     } else {
       addNit(charOffset,
           "'$name' is imported from both '${uri}' and '${otherUri}'.");
     }
     return new KernelInvalidTypeBuilder(name, charOffset, fileUri);
@@ skipping 81 matching lines @@
   }
 
   @override
   void includePart(covariant KernelLibraryBuilder part) {
     super.includePart(part);
     nativeMethods.addAll(part.nativeMethods);
     boundlessTypeVariables.addAll(part.boundlessTypeVariables);
     assert(mixinApplicationClasses.isEmpty);
   }
 }
-
-bool isConstructorName(String name, String className) {
-  if (name.startsWith(className)) {
-    if (name.length == className.length) return true;
-    if (name.startsWith(".", className.length)) return true;
-  }
-  return false;
-}