Remove deprecated methods from ClassBuilder.

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:typed_data' show Uint8List;
 
-import 'package:front_end/file_system.dart';
-import 'package:front_end/src/base/instrumentation.dart' show Instrumentation;
-
-import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart'
-    show KernelTypeInferenceEngine;
-
-import 'package:front_end/src/fasta/kernel/kernel_target.dart'
-    show KernelTarget;
-
-import 'package:front_end/src/fasta/type_inference/type_inference_engine.dart'
-    show TypeInferenceEngine;
-
 import 'package:kernel/ast.dart' show Arguments, Expression, Program;
 
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
 
 import 'package:kernel/core_types.dart' show CoreTypes;
 
 import 'package:kernel/src/incremental_class_hierarchy.dart'
     show IncrementalClassHierarchy;
 
+import '../../../file_system.dart';
+
+import '../../base/instrumentation.dart' show Instrumentation;
+
 import '../builder/builder.dart'
     show
         Builder,
         ClassBuilder,
         EnumBuilder,
         LibraryBuilder,
         NamedTypeBuilder,
         TypeBuilder;
 
 import '../compiler_context.dart' show CompilerContext;
 
 import '../deprecated_problems.dart' show deprecated_inputError;
 
 import '../export.dart' show Export;
 
+import '../fasta_codes.dart'
+    show
+        templateCyclicClassHierarchy,
+        templateExtendingEnum,
+        templateExtendingRestricted,
+        templateIllegalMixin,
+        templateIllegalMixinDueToConstructors,
+        templateIllegalMixinDueToConstructorsCause;
+
+import '../kernel/kernel_shadow_ast.dart' show KernelTypeInferenceEngine;
+
+import '../kernel/kernel_target.dart' show KernelTarget;
+
 import '../loader.dart' show Loader;
 
 import '../parser/class_member_parser.dart' show ClassMemberParser;
 
 import '../scanner.dart' show ErrorToken, ScannerResult, Token, scan;
 
+import '../type_inference/type_inference_engine.dart' show TypeInferenceEngine;
+
 import 'diet_listener.dart' show DietListener;
 
 import 'diet_parser.dart' show DietParser;
 
 import 'outline_builder.dart' show OutlineBuilder;
 
 import 'source_class_builder.dart' show SourceClassBuilder;
 
 import 'source_library_builder.dart' show SourceLibraryBuilder;
 
@@ skipping 297 matching lines @@
       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.deprecated_addCompileTimeError(
-            cls.charOffset,
-            "'${cls.fullNameForErrors}' is a supertype of itself via "
-            "'$involvedString'.");
+        cls.addCompileTimeError(
+            templateCyclicClassHierarchy.withArguments(
+                cls.fullNameForErrors, involvedString),
+            cls.charOffset);
       }
     });
     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.deprecated_addCompileTimeError(
-              cls.charOffset,
-              "'${supertype.name}' is an enum and can't be extended or "
-              "implemented.");
+          cls.addCompileTimeError(
+              templateExtendingEnum.withArguments(supertype.name),
+              cls.charOffset);
         } else if (!cls.library.mayImplementRestrictedTypes &&
             blackListedClasses.contains(supertype)) {
-          cls.deprecated_addCompileTimeError(
-              cls.charOffset,
-              "'${supertype.name}' is restricted and can't be extended or "
-              "implemented.");
+          cls.addCompileTimeError(
+              templateExtendingRestricted.withArguments(supertype.name),
+              cls.charOffset);
         }
       }
       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.deprecated_addCompileTimeError(
-                    cls.charOffset,
-                    "Can't use '${builder.fullNameForErrors}' as a mixin "
-                    "because it has constructors.");
-                builder.deprecated_addCompileTimeError(
-                    constructory.charOffset,
-                    "This constructor prevents using "
-                    "'${builder.fullNameForErrors}' as a mixin.");
+                cls.addCompileTimeError(
+                    templateIllegalMixinDueToConstructors
+                        .withArguments(builder.fullNameForErrors),
+                    cls.charOffset);
+                builder.addCompileTimeError(
+                    templateIllegalMixinDueToConstructorsCause
+                        .withArguments(builder.fullNameForErrors),
+                    constructory.charOffset);
               }
             }
           }
         }
         if (!isClassBuilder) {
-          cls.deprecated_addCompileTimeError(cls.charOffset,
-              "The type '${mixedInType.fullNameForErrors}' can't be mixed in.");
+          cls.addCompileTimeError(
+              templateIllegalMixin.withArguments(mixedInType.fullNameForErrors),
+              cls.charOffset);
         }
       }
     }
     ticker.logMs("Checked restricted supertypes");
   }
 
   void buildProgram() {
     builders.forEach((Uri uri, LibraryBuilder library) {
       if (library is SourceLibraryBuilder) {
         libraries.add(library.build(coreLibrary));
@@ skipping 80 matching lines @@
 
   Expression throwCompileConstantError(Expression error) {
     return target.backendTarget.throwCompileConstantError(coreTypes, error);
   }
 
   Expression deprecated_buildCompileTimeError(String message, int offset) {
     return target.backendTarget
         .buildCompileTimeError(coreTypes, message, offset);
   }
 }