Deprecate all diagnostics methods that use strings.

pkg/front_end/lib/src/fasta/source/outline_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.outline_builder;
 
 import 'package:kernel/ast.dart' show ProcedureKind;
 
 import '../fasta_codes.dart' show FastaMessage, codeExpectedBlockToSkip;
 
 import '../parser/parser.dart' show FormalParameterType, MemberKind, optional;
 
 import '../parser/identifier_context.dart' show IdentifierContext;
 
 import '../../scanner/token.dart' show Token;
 
 import '../util/link.dart' show Link;
 
 import '../combinator.dart' show Combinator;
 
-import '../errors.dart' show internalError;
+import '../deprecated_problems.dart' show deprecated_internalProblem;
 
 import '../builder/builder.dart';
 
 import '../modifier.dart' show abstractMask, externalMask, Modifier;
 
 import 'source_library_builder.dart' show SourceLibraryBuilder;
 
 import 'unhandled_listener.dart' show NullValue, Unhandled, UnhandledListener;
 
 import '../parser/native_support.dart'
@@ skipping 167 matching lines @@
   }
 
   @override
   void endLiteralString(int interpolationCount, Token endToken) {
     debugEvent("endLiteralString");
     if (interpolationCount == 0) {
       Token token = pop();
       push(unescapeString(token.lexeme));
       push(token.charOffset);
     } else {
-      internalError("String interpolation not implemented.");
+      deprecated_internalProblem("String interpolation not implemented.");
     }
   }
 
   @override
   void handleStringJuxtaposition(int literalCount) {
     debugEvent("StringJuxtaposition");
     List<String> list =
         new List<String>.filled(literalCount, null, growable: false);
     int charOffset = -1;
     for (int i = literalCount - 1; i >= 0; i--) {
@@ skipping 68 matching lines @@
     List<MetadataBuilder> metadata = pop();
     library.addClass(metadata, modifiers, name, typeVariables, supertype,
         interfaces, charOffset);
     checkEmpty(beginToken.charOffset);
   }
 
   ProcedureKind computeProcedureKind(Token token) {
     if (token == null) return ProcedureKind.Method;
     if (optional("get", token)) return ProcedureKind.Getter;
     if (optional("set", token)) return ProcedureKind.Setter;
-    return internalError("Unhandled: ${token.lexeme}");
+    return deprecated_internalProblem("Unhandled: ${token.lexeme}");
   }
 
   @override
   void beginTopLevelMethod(Token token, Token name) {
     library.beginNestedDeclaration(name.lexeme, hasMembers: false);
   }
 
   @override
   void endTopLevelMethod(Token beginToken, Token getOrSet, Token endToken) {
     debugEvent("endTopLevelMethod");
@@ skipping 57 matching lines @@
     if (Operator.subtract == nameOrOperator && formals == null) {
       nameOrOperator = Operator.unaryMinus;
     }
     String name;
     ProcedureKind kind;
     if (nameOrOperator is Operator) {
       name = operatorToString(nameOrOperator);
       kind = ProcedureKind.Operator;
       int requiredArgumentCount = operatorRequiredArgumentCount(nameOrOperator);
       if ((formals?.length ?? 0) != requiredArgumentCount) {
-        library.addCompileTimeError(
+        library.deprecated_addCompileTimeError(
             charOffset,
             "Operator '$name' must have exactly $requiredArgumentCount "
             "parameters.");
       } else {
         if (formals != null) {
           for (FormalParameterBuilder formal in formals) {
             if (!formal.isRequired) {
-              library.addCompileTimeError(formal.charOffset,
+              library.deprecated_addCompileTimeError(formal.charOffset,
                   "An operator can't have optional parameters.");
             }
           }
         }
       }
     } else {
       name = nameOrOperator;
       kind = computeProcedureKind(getOrSet);
     }
     TypeBuilder returnType = pop();
@@ skipping 150 matching lines @@
         formals = new List<FormalParameterBuilder>.filled(count + 1, null,
             growable: true);
         formals[count] = last;
       }
       popList(count, formals);
     }
     if (formals != null) {
       if (formals.length == 2) {
         // The name may be null for generalized function types.
         if (formals[0].name != null && formals[0].name == formals[1].name) {
-          library.addCompileTimeError(formals[1].charOffset,
+          library.deprecated_addCompileTimeError(formals[1].charOffset,
               "Duplicated parameter name '${formals[1].name}'.");
-          library.addCompileTimeError(formals[0].charOffset,
+          library.deprecated_addCompileTimeError(formals[0].charOffset,
               "Other parameter named '${formals[1].name}'.");
         }
       } else if (formals.length > 2) {
         Map<String, FormalParameterBuilder> seenNames =
             <String, FormalParameterBuilder>{};
         for (FormalParameterBuilder formal in formals) {
           if (formal.name == null) continue;
           if (seenNames.containsKey(formal.name)) {
-            library.addCompileTimeError(formal.charOffset,
+            library.deprecated_addCompileTimeError(formal.charOffset,
                 "Duplicated parameter name '${formal.name}'.");
-            library.addCompileTimeError(seenNames[formal.name].charOffset,
+            library.deprecated_addCompileTimeError(
+                seenNames[formal.name].charOffset,
                 "Other parameter named '${formal.name}'.");
           } else {
             seenNames[formal.name] = formal;
           }
         }
       }
     }
     push(beginToken.charOffset);
     push(formals ?? NullValue.FormalParameters);
   }
@@ skipping 82 matching lines @@
       name = pop();
       if (type is FunctionTypeBuilder) {
         // TODO(ahe): We need to start a nested declaration when parsing the
         // formals and return type so we can correctly bind
         // `type.typeVariables`. A typedef can have type variables, and a new
         // function type can also have type variables (representing the type of
         // a generic function).
         functionType = type;
       } else {
         // TODO(ahe): Improve this error message.
-        library.addCompileTimeError(
+        library.deprecated_addCompileTimeError(
             equals.charOffset, "Can't create typedef from non-function type.");
       }
     }
     List<MetadataBuilder> metadata = pop();
     library.addFunctionTypeAlias(
         metadata, name, typeVariables, functionType, charOffset);
     checkEmpty(typedefKeyword.charOffset);
     silenceParserErrors = true;
   }
 
@@ skipping 177 matching lines @@
         nativeMethodName =
             stringExpectedAfterNative ? extractNativeMethodName(token) : "";
         return recover;
       }
     }
     return super.handleUnrecoverableError(token, message);
   }
 
   @override
   void addCompileTimeErrorFromMessage(FastaMessage message) {
-    library.addCompileTimeError(message.charOffset, message.message,
+    library.deprecated_addCompileTimeError(message.charOffset, message.message,
         fileUri: message.uri);
   }
 
   @override
   Link<Token> handleMemberName(Link<Token> identifiers) {
     if (!enableNative || identifiers.isEmpty) return identifiers;
     return removeNativeClause(identifiers, stringExpectedAfterNative);
   }
 
   @override
   void debugEvent(String name) {
     // printEvent(name);
   }
 }