Remove deprecated_warning.

pkg/front_end/lib/src/fasta/kernel/body_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.body_builder;
 
 import 'package:kernel/ast.dart'
     hide InvalidExpression, InvalidInitializer, InvalidStatement;
 
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
@@ skipping 897 matching lines @@
   }
 
   @override
   Expression toSuperMethodInvocation(MethodInvocation node) {
     Member target = lookupSuperMember(node.name);
     if (target == null || (target is Procedure && !target.isAccessor)) {
       if (target == null) {
         warnUnresolvedSuperMethod(node.name, node.fileOffset);
       } else if (!areArgumentsCompatible(target.function, node.arguments)) {
         target = null;
-        deprecated_warning(
-            "Super class doesn't have a method named '${node.name.name}' "
-            "with matching arguments.",
+        warning(
+            fasta.templateSuperclassMethodArgumentMismatch
+                .withArguments(node.name.name),
             node.fileOffset);
       }
       Expression result;
       if (target != null) {
         result = new KernelDirectMethodInvocation(
             new KernelThisExpression()..fileOffset = node.fileOffset,
             target,
             node.arguments);
       }
       // TODO(ahe): Use [DirectMethodInvocation] when possible, that is,
@@ skipping 49 matching lines @@
           isSetter: isSetter,
           isStatic: isStatic,
           isTopLevel: !isStatic && !isSuper);
       warning(message, charOffset);
       return new KernelSyntheticExpression(new Throw(error));
     }
   }
 
   @override
   void warnUnresolvedSuperGet(Name name, int charOffset) {
-    deprecated_warning(
-        "Super class has no getter named '${name.name}'.", charOffset);
+    warning(fasta.templateSuperclassHasNoGetter.withArguments(name.name),
+        charOffset);
   }
 
   @override
   void warnUnresolvedSuperSet(Name name, int charOffset) {
-    deprecated_warning(
-        "Super class has no setter named '${name.name}'.", charOffset);
+    warning(fasta.templateSuperclassHasNoSetter.withArguments(name.name),
+        charOffset);
   }
 
   @override
   void warnUnresolvedSuperMethod(Name name, int charOffset) {
-    deprecated_warning(
-        "Super class has no method named '${name.name}'.", charOffset);
+    warning(fasta.templateSuperclassHasNoMethod.withArguments(name.name),
+        charOffset);
   }
 
   @override
   Member lookupSuperMember(Name name, {bool isSetter: false}) {
     Class superclass = classBuilder.cls.superclass;
     return superclass == null
         ? null
         : hierarchy.getDispatchTarget(superclass, name, setter: isSetter);
   }
 
@@ skipping 614 matching lines @@
       }
     }
     push(
         new KernelSymbolLiteral(value)..fileOffset = offsetForToken(hashToken));
   }
 
   DartType kernelTypeFromString(
       String name, List<DartType> arguments, int charOffset) {
     Builder builder = scope.lookup(name, charOffset, uri);
     if (builder == null) {
-      deprecated_warning("Type not found: '$name'.", charOffset);
+      warning(fasta.templateTypeNotFound.withArguments(name), charOffset);
       return const InvalidType();
     } else {
       return kernelTypeFromBuilder(builder, arguments, charOffset);
     }
   }
 
   DartType kernelTypeFromBuilder(
       Builder builder, List<DartType> arguments, int charOffset) {
     if (constantExpressionRequired && builder is TypeVariableBuilder) {
       deprecated_addCompileTimeError(charOffset, "Not a constant expression.");
@@ skipping 1618 matching lines @@
     if (member.isNative) {
       push(NullValue.FunctionBody);
     } else {
       push(new Block(<Statement>[
         deprecated_buildCompileTimeErrorStatement(
             "Expected '{'.", token.charOffset)
       ]));
     }
   }
 
-  @override
-  void deprecated_warning(String message, [int charOffset = -1]) {
-    if (constantExpressionRequired) {
-      deprecated_addCompileTimeError(charOffset, message);
-    } else {
-      super.deprecated_warning(message, charOffset);
-    }
-  }
-
   void warningNotError(Message message, int charOffset) {
     super.warning(message, charOffset);
   }
 
   @override
   DartType validatedTypeVariableUse(
       TypeParameterType type, int offset, bool nonInstanceAccessIsError) {
     if (!isInstanceContext && type.parameter.parent is Class) {
-      String message = "Type variables can't be used in static members.";
+      Message message = fasta.messageTypeVariableInStaticContext;
       if (nonInstanceAccessIsError) {
-        deprecated_addCompileTimeError(offset, message);
+        addCompileTimeError(message, offset);
       } else {
-        deprecated_warning(message, offset);
+        warning(message, offset);
       }
       return const InvalidType();
     } else if (constantExpressionRequired) {
       deprecated_addCompileTimeError(
           offset,
           "Type variable '${type.parameter.name}' can't be used as a constant "
           "expression $type.");
     }
     return type;
   }
@@ skipping 517 matching lines @@
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return unhandled(asyncToken.lexeme, "asyncMarkerFromTokens",
         asyncToken.charOffset, null);
   }
 }