Remove deprecated_wrapInCompileTimeError.

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 371 matching lines @@
         FastaAccessor accessor = expression;
         expression = accessor.buildPropertyAccess(
             new IncompletePropertyAccessor(
                 this, period.next, new Name(name, library.library)),
             period.next.offset,
             false);
       }
 
       bool savedConstantExpressionRequired = pop();
       if (expression is! StaticAccessor) {
-        push(deprecated_wrapInCompileTimeError(
-            toValue(expression),
-            "This can't be used as metadata; metadata should be a reference to "
-            "a compile-time constant variable, or "
-            "a call to a constant constructor."));
+        push(wrapInCompileTimeError(
+            toValue(expression), fasta.messageExpressionNotMetadata));
       } else {
         push(toValue(expression));
       }
       constantExpressionRequired = savedConstantExpressionRequired;
     }
   }
 
   @override
   void endMetadataStar(int count, bool forParameter) {
     debugEvent("MetadataStar");
@@ skipping 146 matching lines @@
     if (node is Initializer) {
       initializer = node;
     } else if (node is FastaAccessor) {
       initializer = node.buildFieldInitializer(initializedFields);
     } else if (node is ConstructorInvocation) {
       initializer =
           buildSuperInitializer(node.target, node.arguments, token.charOffset);
     } else {
       Expression value = toValue(node);
       if (node is! Throw) {
-        value = deprecated_wrapInCompileTimeError(
-            value, "Expected an initializer.");
+        value =
+            wrapInCompileTimeError(value, fasta.messageExpectedAnInitializer);
       }
       initializer = buildInvalidInitializer(node, token.charOffset);
     }
     _typeInferrer.inferInitializer(initializer);
     if (member is KernelConstructorBuilder && !member.isExternal) {
       member.addInitializer(initializer);
     } else {
       deprecated_addCompileTimeError(
           token.charOffset, "Can't have initializers: ${member.name}");
     }
@@ skipping 850 matching lines @@
     exitLocalScope();
     push(block);
   }
 
   @override
   void handleAssignmentExpression(Token token) {
     debugEvent("AssignmentExpression");
     Expression value = popForValue();
     var accessor = pop();
     if (accessor is! FastaAccessor) {
-      push(deprecated_buildCompileTimeError(
-          "Can't assign to this.", token.charOffset));
+      push(buildCompileTimeError(fasta.messageNotAnLvalue, token.charOffset));
     } else {
       push(new DelayedAssignment(
           this, token, accessor, value, token.stringValue));
     }
   }
 
   @override
   void enterLoop(int charOffset) {
     if (peek() is LabelTarget) {
       LabelTarget target = peek();
@@ skipping 612 matching lines @@
   }
 
   @override
   void handleUnaryPrefixAssignmentExpression(Token token) {
     debugEvent("UnaryPrefixAssignmentExpression");
     var accessor = pop();
     if (accessor is FastaAccessor) {
       push(accessor.buildPrefixIncrement(incrementOperator(token),
           offset: token.charOffset));
     } else {
-      push(deprecated_wrapInCompileTimeError(
-          toValue(accessor), "Can't assign to this."));
+      push(wrapInCompileTimeError(toValue(accessor), fasta.messageNotAnLvalue));
     }
   }
 
   @override
   void handleUnaryPostfixAssignmentExpression(Token token) {
     debugEvent("UnaryPostfixAssignmentExpression");
     var accessor = pop();
     if (accessor is FastaAccessor) {
       push(new DelayedPostfixIncrement(
           this, token, accessor, incrementOperator(token), null));
     } else {
-      push(deprecated_wrapInCompileTimeError(
-          toValue(accessor), "Can't assign to this."));
+      push(wrapInCompileTimeError(toValue(accessor), fasta.messageNotAnLvalue));
     }
   }
 
   @override
   void endConstructorReference(
       Token start, Token periodBeforeName, Token endToken) {
     debugEvent("ConstructorReference");
     pushQualifiedReference(start, periodBeforeName);
   }
 
@@ skipping 995 matching lines @@
     // TODO(ahe): This method should be passed the erroneous expression, wrap
     // it in a class (TBD) from which the erroneous expression can be easily
     // extracted. Similar for statements and initializers. See also [issue
     // 29717](https://github.com/dart-lang/sdk/issues/29717)
     library.addCompileTimeError(message, charOffset, uri, wasHandled: true);
     return new KernelSyntheticExpression(library.loader
         .throwCompileConstantError(
             library.loader.buildCompileTimeError(message, charOffset, uri)));
   }
 
-  Expression deprecated_wrapInCompileTimeError(
-      Expression expression, String message) {
+  Expression wrapInCompileTimeError(Expression expression, Message message) {
     return new Let(
         new VariableDeclaration.forValue(expression)
           ..fileOffset = expression.fileOffset,
-        deprecated_buildCompileTimeError(message, expression.fileOffset))
+        buildCompileTimeError(message, expression.fileOffset))
       ..fileOffset = expression.fileOffset;
   }
 
   Expression buildFallThroughError(int charOffset) {
     warningNotError(fasta.messageSwitchCaseFallThrough, charOffset);
 
     Location location = messages.getLocationFromUri(uri, charOffset);
 
     return new Throw(buildStaticInvocation(
         library.loader.coreTypes.fallThroughErrorUrlAndLineConstructor,
@@ skipping 685 matching lines @@
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return unhandled(asyncToken.lexeme, "asyncMarkerFromTokens",
         asyncToken.charOffset, null);
   }
 }