Deprecate all diagnostics methods that use strings.

pkg/front_end/lib/src/fasta/kernel/kernel_library_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_library_builder;
 
 import 'package:front_end/src/scanner/token.dart' show Token;
 
 import 'package:kernel/ast.dart';
 
 import 'package:kernel/clone.dart' show CloneVisitor;
 
-import '../errors.dart' show internalError;
+import '../deprecated_problems.dart' show deprecated_internalProblem;
 
 import '../loader.dart' show Loader;
 
 import '../modifier.dart'
     show abstractMask, namedMixinApplicationMask, staticMask;
 
 import '../source/source_library_builder.dart'
     show DeclarationBuilder, SourceLibraryBuilder;
 
 import '../source/source_class_builder.dart' show SourceClassBuilder;
 
 import '../util/relativize.dart' show relativizeUri;
 
 import 'kernel_builder.dart'
     show
-        AccessErrorBuilder,
+        deprecated_AccessErrorBuilder,
         Builder,
         BuiltinTypeBuilder,
         ClassBuilder,
         ConstructorReferenceBuilder,
         FormalParameterBuilder,
         InvalidTypeBuilder,
         KernelConstructorBuilder,
         KernelEnumBuilder,
         KernelFieldBuilder,
         KernelFormalParameterBuilder,
@@ skipping 101 matching lines @@
       while (member != null) {
         member.parent = cls;
         member = member.next;
       }
     }
 
     void setParentAndCheckConflicts(String name, MemberBuilder member) {
       if (typeVariablesByName != null) {
         TypeVariableBuilder tv = typeVariablesByName[name];
         if (tv != null) {
-          cls.addCompileTimeError(
+          cls.deprecated_addCompileTimeError(
               member.charOffset, "Conflict with type variable '$name'.");
-          cls.addCompileTimeError(tv.charOffset, "This is the type variable.");
+          cls.deprecated_addCompileTimeError(
+              tv.charOffset, "This is the type variable.");
         }
       }
       setParent(name, member);
     }
 
     members.forEach(setParentAndCheckConflicts);
     constructors.forEach(setParentAndCheckConflicts);
     // Formally, a setter has the name `id=`, so it can never conflict with a
     // type variable.
     setters.forEach(setParent);
     addBuilder(className, cls, charOffset);
   }
 
   Map<String, TypeVariableBuilder> checkTypeVariables(
       List<TypeVariableBuilder> typeVariables, Builder owner) {
     if (typeVariables?.isEmpty ?? true) return null;
     Map<String, TypeVariableBuilder> typeVariablesByName =
         <String, TypeVariableBuilder>{};
     for (TypeVariableBuilder tv in typeVariables) {
       TypeVariableBuilder existing = typeVariablesByName[tv.name];
       if (existing != null) {
-        addCompileTimeError(tv.charOffset,
+        deprecated_addCompileTimeError(tv.charOffset,
             "A type variable can't have the same name as another.");
-        addCompileTimeError(
+        deprecated_addCompileTimeError(
             existing.charOffset, "The other type variable named '${tv.name}'.");
       } else {
         typeVariablesByName[tv.name] = tv;
         if (owner is ClassBuilder) {
           // Only classes and type variables can't have the same name. See
           // [#29555](https://github.com/dart-lang/sdk/issues/29555).
           if (tv.name == owner.name) {
-            addCompileTimeError(
+            deprecated_addCompileTimeError(
                 tv.charOffset,
                 "A type variable can't have the same name as its enclosing "
                 "declaration.");
           }
         }
       }
     }
     return typeVariablesByName;
   }
 
@@ skipping 293 matching lines @@
     int index = name.indexOf(".");
     if (startsWithClassName && index == className.length) {
       // Named constructor or factory.
       return name.substring(index + 1);
     }
     if (index == -1) {
       // A legal name for a regular method, but not for a constructor.
       return null;
     }
     String suffix = name.substring(index + 1);
-    addCompileTimeError(
+    deprecated_addCompileTimeError(
         charOffset,
         "'$name' isn't a legal method name.\n"
         "Did you mean '$className.$suffix'?");
     return suffix;
   }
 
   void addProcedure(
       List<MetadataBuilder> metadata,
       int modifiers,
       KernelTypeBuilder returnType,
@@ skipping 157 matching lines @@
       library.addMember(builder.build(this)..isStatic = true);
     } else if (builder is KernelFunctionTypeAliasBuilder) {
       library.addTypedef(builder.build(this));
     } else if (builder is KernelEnumBuilder) {
       library.addClass(builder.build(this, coreLibrary));
     } else if (builder is PrefixBuilder) {
       // Ignored. Kernel doesn't represent prefixes.
     } else if (builder is BuiltinTypeBuilder) {
       // Nothing needed.
     } else {
-      internalError("Unhandled builder: ${builder.runtimeType}");
+      deprecated_internalProblem("Unhandled builder: ${builder.runtimeType}");
     }
   }
 
   @override
   Library build(LibraryBuilder coreLibrary) {
     super.build(coreLibrary);
     library.name = name;
     library.procedures.sort(compareProcedures);
     return library;
   }
 
   @override
   Builder buildAmbiguousBuilder(
       String name, Builder builder, Builder other, int charOffset,
       {bool isExport: false, bool isImport: false}) {
     // TODO(ahe): Can I move this to Scope or Prefix?
     if (builder == other) return builder;
     if (builder is InvalidTypeBuilder) return builder;
     if (other is InvalidTypeBuilder) return other;
-    if (builder is AccessErrorBuilder) {
-      AccessErrorBuilder error = builder;
+    if (builder is deprecated_AccessErrorBuilder) {
+      deprecated_AccessErrorBuilder error = builder;
       builder = error.builder;
     }
-    if (other is AccessErrorBuilder) {
-      AccessErrorBuilder error = other;
+    if (other is deprecated_AccessErrorBuilder) {
+      deprecated_AccessErrorBuilder error = other;
       other = error.builder;
     }
     bool isLocal = false;
     Builder preferred;
     Uri uri;
     Uri otherUri;
     Uri preferredUri;
     Uri hiddenUri;
     if (scope.local[name] == builder) {
       isLocal = true;
       preferred = builder;
       hiddenUri = other.computeLibraryUri();
     } else {
       uri = builder.computeLibraryUri();
       otherUri = other.computeLibraryUri();
       if (otherUri?.scheme == "dart" && uri?.scheme != "dart") {
         preferred = builder;
         preferredUri = uri;
         hiddenUri = otherUri;
       } else if (uri?.scheme == "dart" && otherUri?.scheme != "dart") {
         preferred = other;
         preferredUri = otherUri;
         hiddenUri = uri;
       }
     }
     if (preferred != null) {
       if (isLocal) {
         if (isExport) {
-          addNit(charOffset,
+          deprecated_addNit(charOffset,
               "Local definition of '$name' hides export from '${hiddenUri}'.");
         } else {
-          addNit(charOffset,
+          deprecated_addNit(charOffset,
               "Local definition of '$name' hides import from '${hiddenUri}'.");
         }
       } else {
         if (isExport) {
-          addNit(
+          deprecated_addNit(
               charOffset,
               "Export of '$name' (from '${preferredUri}') hides export from "
               "'${hiddenUri}'.");
         } else {
-          addNit(
+          deprecated_addNit(
               charOffset,
               "Import of '$name' (from '${preferredUri}') hides import from "
               "'${hiddenUri}'.");
         }
       }
       return preferred;
     }
     if (builder.next == null && other.next == null) {
       if (isImport && builder is PrefixBuilder && other is PrefixBuilder) {
         // Handles the case where the same prefix is used for different
         // imports.
         return builder
           ..exports.merge(other.exports,
               (String name, Builder existing, Builder member) {
             return buildAmbiguousBuilder(name, existing, member, charOffset,
                 isExport: isExport, isImport: isImport);
           });
       }
     }
     String message = isExport
         ? "'$name' is exported from both '${uri}' and '${otherUri}'."
         : "'$name' is imported from both '${uri}' and '${otherUri}'.";
-    addNit(charOffset, message);
+    deprecated_addNit(charOffset, message);
     return new KernelInvalidTypeBuilder(name, charOffset, fileUri, message);
   }
 
   int finishStaticInvocations() {
     CloneVisitor cloner;
     for (var list in argumentsWithMissingDefaultValues) {
       final Arguments arguments = list[0];
       final FunctionNode function = list[1];
 
       Expression defaultArgumentFrom(Expression expression) {
@@ skipping 79 matching lines @@
           mixinApplicationClasses.putIfAbsent(name, () => builder);
       if (existing != builder) {
         part.scope.local.remove(name);
       }
     });
     super.includePart(part);
     nativeMethods.addAll(part.nativeMethods);
     boundlessTypeVariables.addAll(part.boundlessTypeVariables);
   }
 }