Rewrite mixin application handling in Fasta.

pkg/front_end/lib/src/fasta/source/source_loader.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_loader;
 
 import 'dart:async' show Future;
 
 import 'dart:io';
 import 'dart:typed_data' show Uint8List;
@@ skipping 14 matching lines @@
 
 import 'package:front_end/src/fasta/type_inference/type_inference_engine.dart'
     show TypeInferenceEngine;
 
 import 'package:kernel/ast.dart' show Program;
 
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
 
 import 'package:kernel/core_types.dart' show CoreTypes;
 
-import '../builder/builder.dart' show Builder, ClassBuilder, LibraryBuilder;
+import '../builder/builder.dart'
+    show
+        Builder,
+        ClassBuilder,
+        EnumBuilder,
+        LibraryBuilder,
+        NamedTypeBuilder,
+        TypeBuilder;
 
 import '../compiler_context.dart' show CompilerContext;
 
 import '../errors.dart' show inputError;
 
 import '../export.dart' show Export;
 
 import '../loader.dart' show Loader;
 
 import '../parser/class_member_parser.dart' show ClassMemberParser;
@@ skipping 312 matching lines @@
     realCycles.forEach((ClassBuilder cls, Set<ClassBuilder> cycles) {
       target.breakCycle(cls);
       if (reported.add(cls)) {
         List<ClassBuilder> involved = <ClassBuilder>[];
         for (ClassBuilder cls in cycles) {
           if (realCycles.containsKey(cls)) {
             involved.add(cls);
             reported.add(cls);
           }
         }
+        String involvedString =
+            involved.map((c) => c.fullNameForErrors).join("', '");
         cls.addCompileTimeError(
             cls.charOffset,
-            "'${cls.name}' is a supertype of "
-            "itself via '${involved.map((c) => c.name).join(' ')}'.");
+            "'${cls.fullNameForErrors}' is a supertype of itself via "
+            "'$involvedString'.");
       }
     });
     ticker.logMs("Found cycles");
+    Set<ClassBuilder> blackListedClasses = new Set<ClassBuilder>.from([
+      coreLibrary["bool"],
+      coreLibrary["int"],
+      coreLibrary["num"],
+      coreLibrary["double"],
+      coreLibrary["String"],
+    ]);
+    for (ClassBuilder cls in allClasses) {
+      if (cls.library.loader != this) continue;
+      Set<ClassBuilder> directSupertypes = new Set<ClassBuilder>();
+      target.addDirectSupertype(cls, directSupertypes);
+      for (ClassBuilder supertype in directSupertypes) {
+        if (supertype is EnumBuilder) {
+          cls.addCompileTimeError(
+              cls.charOffset,
+              "'${supertype.name}' is an enum and can't be extended or "
+              "implemented.");
+        } else if (cls.library != coreLibrary &&
+            blackListedClasses.contains(supertype)) {
+          cls.addCompileTimeError(
+              cls.charOffset,
+              "'${supertype.name}' is restricted and can't be extended or "
+              "implemented.");
+        }
+      }
+      TypeBuilder mixedInType = cls.mixedInType;
+      if (mixedInType != null) {
+        bool isClassBuilder = false;
+        if (mixedInType is NamedTypeBuilder) {
+          var builder = mixedInType.builder;
+          if (builder is ClassBuilder) {
+            isClassBuilder = true;
+            for (Builder constructory in builder.constructors.local.values) {
+              if (constructory.isConstructor && !constructory.isSynthetic) {
+                cls.addCompileTimeError(
+                    cls.charOffset,
+                    "Can't use '${builder.fullNameForErrors}' as a mixin "
+                    "because it has constructors.");
+                builder.addCompileTimeError(
+                    constructory.charOffset,
+                    "This constructor prevents using "
+                    "'${builder.fullNameForErrors}' as a mixin.");
+              }
+            }
+          }
+        }
+        if (!isClassBuilder) {
+          cls.addCompileTimeError(cls.charOffset,
+              "The type '${mixedInType.fullNameForErrors}' can't be mixed in.");
+        }
+      }
+    }
+    ticker.logMs("Checked restricted supertypes");
   }
 
   void buildProgram() {
     builders.forEach((Uri uri, LibraryBuilder library) {
       if (library is SourceLibraryBuilder) {
         libraries.add(library.build(coreLibrary));
       }
     });
     ticker.logMs("Built program");
   }
@@ skipping 35 matching lines @@
   /// Performs the second phase of top level initializer inference, which is to
   /// visit fields and top level variables in topologically-sorted order and
   /// assign their types.
   void performInitializerInference() {
     typeInferenceEngine.finishTopLevel();
     ticker.logMs("Performed initializer inference");
   }
 
   List<Uri> getDependencies() => sourceBytes.keys.toList();
 }