Deprecate all diagnostics methods that use strings.

pkg/front_end/lib/src/fasta/kernel/kernel_procedure_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_procedure_builder;
 
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart'
     show KernelProcedure;
 
 import 'package:front_end/src/fasta/source/source_library_builder.dart'
@@ skipping 26 matching lines @@
         StringLiteral,
         SuperInitializer,
         TypeParameter,
         VariableDeclaration,
         VariableGet,
         VoidType,
         setParents;
 
 import 'package:kernel/type_algebra.dart' show containsTypeVariable, substitute;
 
-import '../errors.dart' show internalError;
+import '../deprecated_problems.dart' show deprecated_internalProblem;
 
-import '../messages.dart' show warning;
+import '../messages.dart' show deprecated_warning;
 
 import '../loader.dart' show Loader;
 
 import 'kernel_builder.dart'
     show
         Builder,
         ClassBuilder,
         ConstructorReferenceBuilder,
         FormalParameterBuilder,
         KernelFormalParameterBuilder,
         KernelLibraryBuilder,
         KernelTypeBuilder,
         KernelTypeVariableBuilder,
         LibraryBuilder,
         MetadataBuilder,
         ProcedureBuilder,
         TypeVariableBuilder,
         isRedirectingGenerativeConstructorImplementation,
-        memberError;
+        deprecated_memberError;
 
 abstract class KernelFunctionBuilder
     extends ProcedureBuilder<KernelTypeBuilder> {
   final String nativeMethodName;
 
   FunctionNode function;
 
   Statement actualBody;
 
   KernelFunctionBuilder(
       List<MetadataBuilder> metadata,
       int modifiers,
       KernelTypeBuilder returnType,
       String name,
       List<TypeVariableBuilder> typeVariables,
       List<FormalParameterBuilder> formals,
       KernelLibraryBuilder compilationUnit,
       int charOffset,
       this.nativeMethodName)
       : super(metadata, modifiers, returnType, name, typeVariables, formals,
             compilationUnit, charOffset);
 
   void set body(Statement newBody) {
     if (newBody != null) {
       if (isAbstract) {
-        return internalError("Attempting to set body on abstract method.");
+        return deprecated_internalProblem(
+            "Attempting to set body on abstract method.");
       }
       if (isExternal) {
-        return library.addCompileTimeError(
+        return library.deprecated_addCompileTimeError(
             newBody.fileOffset, "An external method can't have a body.");
       }
       if (isConstructor && isConst) {
-        return library.addCompileTimeError(
+        return library.deprecated_addCompileTimeError(
             newBody.fileOffset, "A const constructor can't have a body.");
       }
     }
     actualBody = newBody;
     if (function != null) {
       function.body = newBody;
       newBody?.parent = function;
     }
   }
 
@@ skipping 31 matching lines @@
       List<TypeParameter> typeParameters = parent.target.typeParameters;
       if (typeParameters.isNotEmpty) {
         Map<TypeParameter, DartType> substitution;
         DartType removeTypeVariables(DartType type) {
           if (substitution == null) {
             substitution = <TypeParameter, DartType>{};
             for (TypeParameter parameter in typeParameters) {
               substitution[parameter] = const DynamicType();
             }
           }
-          warning(fileUri, charOffset,
+          deprecated_warning(fileUri, charOffset,
               "Can only use type variables in instance methods.");
           return substitute(type, substitution);
         }
 
         Set<TypeParameter> set = typeParameters.toSet();
         for (VariableDeclaration parameter in result.positionalParameters) {
           if (containsTypeVariable(parameter.type, set)) {
             parameter.type = removeTypeVariables(parameter.type);
           }
         }
@@ skipping 182 matching lines @@
 
   FunctionNode buildFunction(LibraryBuilder library) {
     // TODO(ahe): Should complain if another type is explicitly set.
     return super.buildFunction(library)..returnType = const VoidType();
   }
 
   Constructor get target => constructor;
 
   void checkSuperOrThisInitializer(Initializer initializer) {
     if (superInitializer != null || redirectingInitializer != null) {
-      memberError(
+      deprecated_memberError(
           target,
           "Can't have more than one 'super' or 'this' initializer.",
           initializer.fileOffset);
     }
   }
 
   void addInitializer(Initializer initializer) {
     List<Initializer> initializers = constructor.initializers;
     if (initializer is SuperInitializer) {
       checkSuperOrThisInitializer(initializer);
       superInitializer = initializer;
     } else if (initializer is RedirectingInitializer) {
       checkSuperOrThisInitializer(initializer);
       redirectingInitializer = initializer;
       if (constructor.initializers.isNotEmpty) {
-        memberError(target, "'this' initializer must be the only initializer.",
+        deprecated_memberError(
+            target,
+            "'this' initializer must be the only initializer.",
             initializer.fileOffset);
       }
     } else if (redirectingInitializer != null) {
-      memberError(target, "'this' initializer must be the only initializer.",
+      deprecated_memberError(
+          target,
+          "'this' initializer must be the only initializer.",
           initializer.fileOffset);
     } else if (superInitializer != null) {
       // If there is a super initializer ([initializer] isn't it), we need to
       // insert [initializer] before the super initializer (thus ensuring that
       // the super initializer is always last).
       assert(superInitializer != initializer);
       assert(initializers.last == superInitializer);
       initializers.removeLast();
       if (!hasMovedSuperInitializer) {
         // To preserve correct evaluation order, the arguments to super call
@@ skipping 19 matching lines @@
         }
       }
       initializers.add(initializer..parent = constructor);
       initializers.add(superInitializer);
       return;
     }
     initializers.add(initializer);
     initializer.parent = constructor;
   }
 }