Remove deprecated api from LibraryBuilder.

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 '../../scanner/token.dart' show Token;
 
 import '../builder/builder.dart';
 
 import '../combinator.dart' show Combinator;
 
-import '../fasta_codes.dart' show Message, codeExpectedBlockToSkip;
+import '../fasta_codes.dart'
+    show
+        Message,
+        codeExpectedBlockToSkip,
+        messageOperatorWithOptionalFormals,
+        messageTypedefNotFunction,
+        templateDuplicatedParameterName,
+        templateDuplicatedParameterNameCause,
+        templateOperatorParameterMismatch;
 
 import '../modifier.dart' show abstractMask, externalMask, Modifier;
 
 import '../operator.dart'
     show
         Operator,
         operatorFromString,
         operatorToString,
         operatorRequiredArgumentCount;
 
@@ skipping 341 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.deprecated_addCompileTimeError(
-            charOffset,
-            "Operator '$name' must have exactly $requiredArgumentCount "
-            "parameters.");
+        addCompileTimeError(
+            templateOperatorParameterMismatch.withArguments(
+                name, requiredArgumentCount),
+            charOffset);
       } else {
         if (formals != null) {
           for (FormalParameterBuilder formal in formals) {
             if (!formal.isRequired) {
-              library.deprecated_addCompileTimeError(formal.charOffset,
-                  "An operator can't have optional parameters.");
+              addCompileTimeError(
+                  messageOperatorWithOptionalFormals, formal.charOffset);
             }
           }
         }
       }
     } else {
       name = nameOrOperator;
       kind = computeProcedureKind(getOrSet);
     }
     TypeBuilder returnType = pop();
     int modifiers =
@@ skipping 149 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.deprecated_addCompileTimeError(formals[1].charOffset,
-              "Duplicated parameter name '${formals[1].name}'.");
-          library.deprecated_addCompileTimeError(formals[0].charOffset,
-              "Other parameter named '${formals[1].name}'.");
+          addCompileTimeError(
+              templateDuplicatedParameterName.withArguments(formals[1].name),
+              formals[1].charOffset);
+          addCompileTimeError(
+              templateDuplicatedParameterNameCause
+                  .withArguments(formals[1].name),
+              formals[0].charOffset);
         }
       } 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.deprecated_addCompileTimeError(formal.charOffset,
-                "Duplicated parameter name '${formal.name}'.");
-            library.deprecated_addCompileTimeError(
-                seenNames[formal.name].charOffset,
-                "Other parameter named '${formal.name}'.");
+            addCompileTimeError(
+                templateDuplicatedParameterName.withArguments(formal.name),
+                formal.charOffset);
+            addCompileTimeError(
+                templateDuplicatedParameterNameCause.withArguments(formal.name),
+                seenNames[formal.name].charOffset);
           } else {
             seenNames[formal.name] = formal;
           }
         }
       }
     }
     push(beginToken.charOffset);
     push(formals ?? NullValue.FormalParameters);
   }
 
@@ skipping 81 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.deprecated_addCompileTimeError(
-            equals.charOffset, "Can't create typedef from non-function type.");
+        addCompileTimeError(messageTypedefNotFunction, equals.charOffset);
       }
     }
     List<MetadataBuilder> metadata = pop();
     library.addFunctionTypeAlias(
         metadata, name, typeVariables, functionType, charOffset);
     checkEmpty(typedefKeyword.charOffset);
     silenceParserErrors = true;
   }
 
   @override
@@ skipping 176 matching lines @@
         nativeMethodName =
             stringExpectedAfterNative ? extractNativeMethodName(token) : "";
         return recover;
       }
     }
     return super.handleUnrecoverableError(token, message);
   }
 
   @override
   void addCompileTimeError(Message message, int charOffset) {
-    library.deprecated_addCompileTimeError(charOffset, message.message,
-        fileUri: uri);
+    library.addCompileTimeError(message, charOffset, 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);
   }
 }