Deprecate all diagnostics methods that use strings.

pkg/front_end/lib/src/fasta/source/source_class_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_class_builder;
 
 import 'package:front_end/src/fasta/builder/class_builder.dart'
     show ClassBuilder;
 
 import 'package:front_end/src/fasta/source/source_library_builder.dart'
     show SourceLibraryBuilder;
 
 import 'package:kernel/ast.dart'
     show Class, Constructor, Supertype, TreeNode, setParents;
 
-import '../errors.dart' show internalError;
+import '../deprecated_problems.dart' show deprecated_internalProblem;
 
 import '../kernel/kernel_builder.dart'
     show
         Builder,
         ConstructorReferenceBuilder,
         KernelClassBuilder,
         KernelFieldBuilder,
         KernelFunctionBuilder,
         KernelLibraryBuilder,
         KernelTypeBuilder,
@@ skipping 57 matching lines @@
   Class build(KernelLibraryBuilder library, LibraryBuilder coreLibrary) {
     void buildBuilders(String name, Builder builder) {
       do {
         if (builder is KernelFieldBuilder) {
           // TODO(ahe): It would be nice to have a common interface for the
           // build method to avoid duplicating these two cases.
           cls.addMember(builder.build(library));
         } else if (builder is KernelFunctionBuilder) {
           cls.addMember(builder.build(library));
         } else {
-          internalError("Unhandled builder: ${builder.runtimeType}");
+          deprecated_internalProblem(
+              "Unhandled builder: ${builder.runtimeType}");
         }
         builder = builder.next;
       } while (builder != null);
     }
 
     scope.forEach(buildBuilders);
     constructors.forEach(buildBuilders);
     cls.supertype = supertype?.buildSupertype(library);
     cls.mixedInType = mixedInType?.buildSupertype(library);
     // TODO(ahe): If `cls.supertype` is null, and this isn't Object, report a
     // compile-time error.
     cls.isAbstract = isAbstract;
     if (interfaces != null) {
       for (KernelTypeBuilder interface in interfaces) {
         Supertype supertype = interface.buildSupertype(library);
         if (supertype != null) {
           // TODO(ahe): Report an error if supertype is null.
           cls.implementedTypes.add(supertype);
         }
       }
     }
 
     constructors.forEach((String name, Builder constructor) {
       Builder member = scopeBuilder[name];
       if (member == null) return;
       // TODO(ahe): charOffset is missing.
-      addCompileTimeError(
+      deprecated_addCompileTimeError(
           constructor.charOffset, "Conflicts with member '${name}'.");
       if (constructor.isFactory) {
-        addCompileTimeError(member.charOffset,
+        deprecated_addCompileTimeError(member.charOffset,
             "Conflicts with factory '${this.name}.${name}'.");
       } else {
-        addCompileTimeError(member.charOffset,
+        deprecated_addCompileTimeError(member.charOffset,
             "Conflicts with constructor '${this.name}.${name}'.");
       }
     });
 
     scope.setters.forEach((String name, Builder setter) {
       Builder member = scopeBuilder[name];
       if (member == null || !member.isField || member.isFinal) return;
       // TODO(ahe): charOffset is missing.
       var report = member.isInstanceMember != setter.isInstanceMember
-          ? addWarning
-          : addCompileTimeError;
+          ? deprecated_addWarning
+          : deprecated_addCompileTimeError;
       report(setter.charOffset, "Conflicts with member '${name}'.");
       report(member.charOffset, "Conflicts with setter '${name}'.");
     });
 
     cls.procedures.sort(compareProcedures);
     return cls;
   }
 
   void addSyntheticConstructor(Constructor constructor) {
     String name = constructor.name.name;
     cls.constructors.add(constructor);
     constructor.parent = cls;
     DillMemberBuilder memberBuilder = new DillMemberBuilder(constructor, this);
     memberBuilder.next = constructorScopeBuilder[name];
     constructorScopeBuilder.addMember(name, memberBuilder);
   }
 
   @override
   void prepareInitializerInference(
       SourceLibraryBuilder library, ClassBuilder currentClass) {
     scope.forEach((name, builder) {
       builder.prepareInitializerInference(library, this);
     });
   }
 }