Implement type variables in mixin applications.

pkg/front_end/lib/src/fasta/source/source_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.source_library_builder;
 
 import 'package:kernel/ast.dart' show
     AsyncMarker,
     ProcedureKind;
 
 import '../combinator.dart' show
     Combinator;
 
 import '../errors.dart' show
     internalError;
 
 import '../import.dart' show
     Import;
 
 import 'source_loader.dart' show
     SourceLoader;
 
 import '../builder/scope.dart' show
     Scope;
 
 import '../builder/builder.dart' show
     Builder,
+    ClassBuilder,
     ConstructorReferenceBuilder,
     FormalParameterBuilder,
     LibraryBuilder,
     MemberBuilder,
     MetadataBuilder,
     PrefixBuilder,
     ProcedureBuilder,
     TypeBuilder,
     TypeDeclarationBuilder,
     TypeVariableBuilder,
@@ skipping 12 matching lines @@
   final List<SourceLibraryBuilder<T, R>> parts = <SourceLibraryBuilder<T, R>>[];
 
   final List<Import> imports = <Import>[];
 
   final Map<String, Builder> exports = <String, Builder>{};
 
   final Scope scope = new Scope(<String, Builder>{}, null, isModifiable: false);
 
   final Uri fileUri;
 
+  final List<List> implementationBuilders = <List<List>>[];
+
   String name;
 
   String partOf;
 
   List<MetadataBuilder> metadata;
 
   /// The current declaration that is being built. When we start parsing a
   /// declaration (class, method, and so on), we don't have enough information
   /// to create a builder and this object records its members and types until,
   /// for example, [addClass] is called.
@@ skipping 121 matching lines @@
       AsyncMarker asyncModifier, ConstructorReferenceBuilder redirectionTarget,
       int charOffset, String nativeMethodName);
 
   FormalParameterBuilder addFormalParameter(
       List<MetadataBuilder> metadata, int modifiers,
       T type, String name, bool hasThis, int charOffset);
 
   TypeVariableBuilder addTypeVariable(String name, T bound, int charOffset);
 
   Builder addBuilder(String name, Builder builder, int charOffset) {
-    if (name.indexOf(".") != -1) {
+    if (name.indexOf(".") != -1 && name.indexOf("&") == -1) {
       addCompileTimeError(charOffset, "Only constructors and factories can have"
           " names containing a period ('.'): $name");
     }
     // TODO(ahe): Set the parent correctly here. Could then change the
     // implementation of MemberBuilder.isTopLevel to test explicitly for a
     // LibraryBuilder.
     if (currentDeclaration == libraryDeclaration) {
       if (builder is MemberBuilder) {
         builder.parent = this;
       } else if (builder is TypeDeclarationBuilder) {
@@ skipping 12 matching lines @@
     if (builder is PrefixBuilder && existing is PrefixBuilder) {
       assert(existing.next == null);
       builder.exports.forEach((String name, Builder builder) {
         Builder other = existing.exports.putIfAbsent(name, () => builder);
         if (other != builder) {
           existing.exports[name] =
               other.combineAmbiguousImport(name, builder, this);
         }
       });
       return existing;
-    } else if (existing != null && (existing.next != null ||
-            ((!existing.isGetter || !builder.isSetter) &&
-                (!existing.isSetter || !builder.isGetter)))) {
+    } else if (isDuplicatedDefinition(existing, builder)) {
       addCompileTimeError(charOffset, "Duplicated definition of '$name'.");
     }
     return members[name] = builder;
   }
 
+  bool isDuplicatedDefinition(Builder existing, Builder other) {
+    if (existing == null) return false;
+    Builder next = existing.next;
+    if (next == null) {
+      if (existing.isGetter && other.isSetter) return false;
+      if (existing.isSetter && other.isGetter) return false;
+    } else {
+      if (next is ClassBuilder && !next.isMixinApplication) return true;
+    }
+    if (existing is ClassBuilder && other is ClassBuilder) {
+      // We allow multiple mixin applications with the same name. An
+      // alternative is to share these mixin applications. This situation can
+      // happen if you have `class A extends Object with Mixin {}` and `class B
+      // extends Object with Mixin {}` in the same library.
+      return !existing.isMixinApplication || !other.isMixinApplication;
+    }
+    return true;
+  }
+
   void buildBuilder(Builder builder);
 
   R build() {
+    assert(implementationBuilders.isEmpty);
     members.forEach((String name, Builder builder) {
       do {
         buildBuilder(builder);
         builder = builder.next;
       } while (builder != null);
     });
+    for (List list in implementationBuilders) {
+      String name = list[0];
+      Builder builder = list[1];
+      int charOffset = list[2];
+      addBuilder(name, builder, charOffset);
+      buildBuilder(builder);
+    }
     return null;
   }
 
+  void addImplementationBuilder(String name, Builder builder, int charOffset) {
+    implementationBuilders.add([name, builder, charOffset]);
+  }
+
   void validatePart() {
     if (parts.isNotEmpty) {
       internalError("Part with parts: $uri");
     }
     if (exporters.isNotEmpty) {
       internalError(
           "${exporters.first.exporter.uri} attempts to export the part $uri.");
     }
   }
 
@@ skipping 173 matching lines @@
   }
 
   /// Called to register [procedure] as a factory whose types are collected in
   /// [factoryDeclaration]. Later, once the class has been built, we can
   /// synthesize type variables on the factory matching the class'.
   void addFactoryDeclaration(
       ProcedureBuilder procedure, DeclarationBuilder<T> factoryDeclaration) {
     factoryDeclarations[procedure] = factoryDeclaration;
   }
 }