Deprecate all diagnostics methods that use strings.

pkg/front_end/lib/src/fasta/kernel/kernel_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.kernel_class_builder;
 
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart'
     show KernelMember;
 
 import 'package:kernel/ast.dart'
     show
         Class,
         Constructor,
         DartType,
         Expression,
         Field,
         FunctionNode,
         InterfaceType,
         ListLiteral,
         Member,
         Name,
         Procedure,
         ProcedureKind,
         StaticGet,
         Supertype,
         VariableDeclaration;
 
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
 
-import '../errors.dart' show internalError;
+import '../deprecated_problems.dart' show deprecated_internalProblem;
 
 import '../dill/dill_member_builder.dart' show DillMemberBuilder;
 
 import 'kernel_builder.dart'
     show
         Builder,
         ClassBuilder,
         ConstructorReferenceBuilder,
         KernelLibraryBuilder,
         KernelProcedureBuilder,
@@ skipping 34 matching lines @@
     assert(arguments == null || cls.typeParameters.length == arguments.length);
     return arguments == null ? cls.rawType : new InterfaceType(cls, arguments);
   }
 
   List<DartType> buildTypeArguments(
       LibraryBuilder library, List<KernelTypeBuilder> arguments) {
     List<DartType> typeArguments = <DartType>[];
     for (KernelTypeBuilder builder in arguments) {
       DartType type = builder.build(library);
       if (type == null) {
-        internalError("Bad type: ${builder.runtimeType}");
+        deprecated_internalProblem("Bad type: ${builder.runtimeType}");
       }
       typeArguments.add(type);
     }
     return computeDefaultTypeArguments(
         library, cls.typeParameters, typeArguments);
   }
 
   InterfaceType buildType(
       LibraryBuilder library, List<KernelTypeBuilder> arguments) {
     List<DartType> typeArguments;
@@ skipping 31 matching lines @@
             addRedirectingConstructor(builder, library);
             if (targetBuilder is ProcedureBuilder) {
               Member target = targetBuilder.target;
               builder.body = new RedirectingFactoryBody(target);
             } else if (targetBuilder is DillMemberBuilder) {
               builder.body = new RedirectingFactoryBody(targetBuilder.member);
             } else {
               String message = "Redirection constructor target not found: "
                   "${redirectionTarget.fullNameForErrors}";
               if (builder.isConst) {
-                addCompileTimeError(builder.charOffset, message);
+                deprecated_addCompileTimeError(builder.charOffset, message);
               } else {
-                addWarning(builder.charOffset, message);
+                deprecated_addWarning(builder.charOffset, message);
               }
               // CoreTypes aren't computed yet, and this is the outline
               // phase. So we can't and shouldn't create a method body.
               builder.body = new RedirectingFactoryBody.unresolved(
                   redirectionTarget.fullNameForErrors);
             }
           }
         }
       }
     }
@@ skipping 31 matching lines @@
   }
 
   void checkOverrides(ClassHierarchy hierarchy) {
     hierarchy.forEachOverridePair(cls, checkOverride);
     hierarchy.forEachCrossOverridePair(cls, handleCrossOverride);
   }
 
   void checkOverride(
       Member declaredMember, Member interfaceMember, bool isSetter) {
     if (declaredMember is Constructor || interfaceMember is Constructor) {
-      internalError(
+      deprecated_internalProblem(
           "Constructor in override check.", fileUri, declaredMember.fileOffset);
     }
     if (declaredMember is Procedure && interfaceMember is Procedure) {
       if (declaredMember.kind == ProcedureKind.Method &&
           interfaceMember.kind == ProcedureKind.Method) {
         checkMethodOverride(declaredMember, interfaceMember);
       }
     }
     // TODO(ahe): Handle other cases: accessors, operators, and fields.
 
@@ skipping 23 matching lines @@
       // TODO(ahe): Include these checks as well, but the message needs to
       // explain that [declaredMember] is inherited.
       return;
     }
     assert(declaredMember.kind == ProcedureKind.Method);
     assert(interfaceMember.kind == ProcedureKind.Method);
     FunctionNode declaredFunction = declaredMember.function;
     FunctionNode interfaceFunction = interfaceMember.function;
     if (declaredFunction.typeParameters?.length !=
         interfaceFunction.typeParameters?.length) {
-      addWarning(
+      deprecated_addWarning(
           declaredMember.fileOffset,
           "Declared type variables of '$name::${declaredMember.name.name}' "
           "doesn't match those on overridden method "
           "'${interfaceMember.enclosingClass.name}::"
           "${interfaceMember.name.name}'.");
     }
     if (declaredFunction.positionalParameters.length <
             interfaceFunction.requiredParameterCount ||
         declaredFunction.positionalParameters.length <
             interfaceFunction.positionalParameters.length) {
-      addWarning(
+      deprecated_addWarning(
           declaredMember.fileOffset,
           "The method '$name::${declaredMember.name.name}' has fewer "
           "positional arguments than those of overridden method "
           "'${interfaceMember.enclosingClass.name}::"
           "${interfaceMember.name.name}'.");
     }
     if (interfaceFunction.requiredParameterCount <
         declaredFunction.requiredParameterCount) {
-      addWarning(
+      deprecated_addWarning(
           declaredMember.fileOffset,
           "The method '$name::${declaredMember.name.name}' has more "
           "required arguments than those of overridden method "
           "'${interfaceMember.enclosingClass.name}::"
           "${interfaceMember.name.name}'.");
     }
     if (declaredFunction.namedParameters.isEmpty &&
         interfaceFunction.namedParameters.isEmpty) {
       return;
     }
     if (declaredFunction.namedParameters.length <
         interfaceFunction.namedParameters.length) {
-      addWarning(
+      deprecated_addWarning(
           declaredMember.fileOffset,
           "The method '$name::${declaredMember.name.name}' has fewer named "
           "arguments than those of overridden method "
           "'${interfaceMember.enclosingClass.name}::"
           "${interfaceMember.name.name}'.");
     }
     Iterator<VariableDeclaration> declaredNamedParameters =
         declaredFunction.namedParameters.iterator;
     Iterator<VariableDeclaration> interfaceNamedParameters =
         interfaceFunction.namedParameters.iterator;
     outer:
     while (declaredNamedParameters.moveNext() &&
         interfaceNamedParameters.moveNext()) {
       while (declaredNamedParameters.current.name !=
           interfaceNamedParameters.current.name) {
         if (!declaredNamedParameters.moveNext()) {
-          addWarning(
+          deprecated_addWarning(
               declaredMember.fileOffset,
               "The method '$name::${declaredMember.name.name}' doesn't have "
               "the named parameter '${interfaceNamedParameters.current.name}' "
               "of overriden method '${interfaceMember.enclosingClass.name}::"
               "${interfaceMember.name.name}'.");
           break outer;
         }
       }
     }
   }
 
   String get fullNameForErrors {
     return isMixinApplication
         ? "${supertype.fullNameForErrors} with ${mixedInType.fullNameForErrors}"
         : name;
   }
 }