Use FastaMessage instead of String. Part 1.

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 '../fasta_codes.dart'
-    show
-        FastaMessage,
-        codeConstFieldWithoutInitializer,
-        codeExpectedButGot,
-        codeExpectedFunctionBody,
-        codeFinalFieldWithoutInitializer;
+import '../fasta_codes.dart' show Message;
+
+import '../fasta_codes.dart' as fasta;
 
 import '../parser/parser.dart'
     show Assert, FormalParameterType, MemberKind, optional;
 
 import '../parser/identifier_context.dart' show IdentifierContext;
 
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart';
 
 import 'package:front_end/src/fasta/kernel/utils.dart' show offsetForToken;
 
@@ skipping 925 matching lines @@
   }
 
   @override
   Expression throwNoSuchMethodError(
       Expression receiver, String name, Arguments arguments, int charOffset,
       {bool isSuper: false,
       bool isGetter: false,
       bool isSetter: false,
       bool isStatic: false}) {
     String errorName = isSuper ? "super.$name" : name;
-    String message;
+    Message message;
     if (isGetter) {
-      message = "Getter not found: '$errorName'.";
+      message = fasta.templateGetterNotFound.withArguments(errorName);
     } else if (isSetter) {
-      message = "Setter not found: '$errorName'.";
+      message = fasta.templateSetterNotFound.withArguments(errorName);
     } else {
-      message = "Method not found: '$errorName'.";
+      message = fasta.templateMethodNotFound.withArguments(errorName);
     }
     if (constantExpressionRequired) {
       // TODO(ahe): Use error below instead of building a compile-time error,
       // should be:
       //    return library.loader.throwCompileConstantError(error, charOffset);
-      return deprecated_buildCompileTimeError(message, charOffset);
+      return buildCompileTimeError(message, charOffset);
     } else {
       Expression error = library.loader.instantiateNoSuchMethodError(
           receiver, name, arguments, charOffset,
           isMethod: !isGetter && !isSetter,
           isGetter: isGetter,
           isSetter: isSetter,
           isStatic: isStatic,
           isTopLevel: !isStatic && !isSuper);
-      deprecated_warning(message, charOffset);
+      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);
   }
 
@@ skipping 542 matching lines @@
   void handleLiteralList(
       int count, Token beginToken, Token constKeyword, Token endToken) {
     debugEvent("LiteralList");
     List<Expression> expressions = popListForValue(count);
     List<DartType> typeArguments = pop();
     DartType typeArgument;
     if (typeArguments != null) {
       typeArgument = typeArguments.first;
       if (typeArguments.length > 1) {
         typeArgument = null;
-        deprecated_warningNotError(
-            "Too many type arguments on List literal.", beginToken.charOffset);
+        warningNotError(fasta.messageListLiteralTooManyTypeArguments,
+            beginToken.charOffset);
       }
     }
     push(new KernelListLiteral(expressions,
         typeArgument: typeArgument, isConst: constKeyword != null)
       ..fileOffset = offsetForToken(constKeyword ?? beginToken));
   }
 
   @override
   void handleLiteralBool(Token token) {
     debugEvent("LiteralBool");
@@ skipping 20 matching lines @@
       int count, Token beginToken, Token constKeyword, Token endToken) {
     debugEvent("LiteralMap");
     List<MapEntry> entries = popList(count) ?? <MapEntry>[];
     List<DartType> typeArguments = pop();
     DartType keyType;
     DartType valueType;
     if (typeArguments != null) {
       if (typeArguments.length != 2) {
         keyType = null;
         valueType = null;
-        deprecated_warningNotError(
-            "Map literal requires two type arguments.", beginToken.charOffset);
+        warningNotError(fasta.messageListLiteralTypeArgumentMismatch,
+            beginToken.charOffset);
       } else {
         keyType = typeArguments[0];
         valueType = typeArguments[1];
       }
     }
     push(new KernelMapLiteral(entries,
         keyType: keyType, valueType: valueType, isConst: constKeyword != null)
       ..fileOffset = constKeyword?.charOffset ?? offsetForToken(beginToken));
   }
 
@@ skipping 45 matching lines @@
 
   DartType kernelTypeFromBuilder(
       Builder builder, List<DartType> arguments, int charOffset) {
     if (constantExpressionRequired && builder is TypeVariableBuilder) {
       deprecated_addCompileTimeError(charOffset, "Not a constant expression.");
     }
     if (builder.hasProblem) {
       ProblemBuilder problem = builder;
       deprecated_addCompileTimeError(charOffset, problem.deprecated_message);
     } else {
-      deprecated_warningNotError(
-          "Not a type: '${builder.fullNameForErrors}'.", charOffset);
+      warningNotError(
+          fasta.templateNotAType.withArguments(builder.fullNameForErrors),
+          charOffset);
     }
     // TODO(ahe): Create an error somehow.
     return const InvalidType();
   }
 
   @override
   void handleType(Token beginToken, Token endToken) {
     // TODO(ahe): The scope is wrong for return types of generic functions.
     debugEvent("Type");
     List<DartType> arguments = pop();
@@ skipping 25 matching lines @@
             "Can't be used as a type: '${debugName(prefix, suffix)}'.");
         return;
       }
     }
     if (name is Identifier) {
       name = name.name;
     }
     if (name is TypeDeclarationAccessor) {
       push(name.buildType(arguments));
     } else if (name is FastaAccessor) {
-      deprecated_warningNotError(
-          "'${beginToken.lexeme}' isn't a type.", beginToken.charOffset);
+      warningNotError(fasta.templateNotAType.withArguments(beginToken.lexeme),
+          beginToken.charOffset);
       push(const InvalidType());
     } else if (name is TypeBuilder) {
       push(name.build(library));
     } else if (name is Builder) {
       push(kernelTypeFromBuilder(name, arguments, beginToken.charOffset));
     } else if (name is String) {
       push(kernelTypeFromString(name, arguments, beginToken.charOffset));
     } else {
       deprecated_internalProblem("Unhandled: '${name.runtimeType}'.");
     }
+    // TODO(ahe): Unused code fasta.messageNonInstanceTypeVariableUse.
   }
 
   @override
   void beginFunctionType(Token beginToken) {
     debugEvent("beginFunctionType");
     enterFunctionTypeScope();
   }
 
   void enterFunctionTypeScope() {
     List typeVariables = pop();
@@ skipping 1294 matching lines @@
   }
 
   @override
   void handleModifiers(int count) {
     debugEvent("Modifiers");
     // TODO(ahe): Copied from outline_builder.dart.
     push(popList(count) ?? NullValue.Modifiers);
   }
 
   @override
-  void handleRecoverableError(Token token, FastaMessage message) {
+  void handleRecoverableError(Token token, Message message) {
     bool silent = hasParserError ||
-        message.code == codeFinalFieldWithoutInitializer ||
-        message.code == codeConstFieldWithoutInitializer;
-    deprecated_addCompileTimeError(message.charOffset, message.message,
+        message.code == fasta.codeFinalFieldWithoutInitializer ||
+        message.code == fasta.codeConstFieldWithoutInitializer;
+    deprecated_addCompileTimeError(offsetForToken(token), message.message,
         silent: silent);
   }
 
   @override
-  Token handleUnrecoverableError(Token token, FastaMessage message) {
-    if (enableNative && message.code == codeExpectedFunctionBody) {
+  Token handleUnrecoverableError(Token token, Message message) {
+    if (enableNative && message.code == fasta.codeExpectedFunctionBody) {
       Token recover = library.loader.target.skipNativeClause(token);
       if (recover != null) return recover;
-    } else if (message.code == codeExpectedButGot) {
+    } else if (message.code == fasta.codeExpectedButGot) {
       String expected = message.arguments["string"];
       const List<String> trailing = const <String>[")", "}", ";", ","];
       if (trailing.contains(token.stringValue) && trailing.contains(expected)) {
         handleRecoverableError(token, message);
         return newSyntheticToken(token);
       }
     }
     return super.handleUnrecoverableError(token, message);
   }
 
   @override
-  Expression deprecated_buildCompileTimeError(error, [int charOffset = -1]) {
+  Expression deprecated_buildCompileTimeError(String error,
+      [int charOffset = -1]) {
     // 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)
     deprecated_addCompileTimeError(charOffset, error, wasHandled: true);
     return new KernelSyntheticExpression(library.loader
         .throwCompileConstantError(library.loader
             .deprecated_buildCompileTimeError(
                 deprecated_formatUnexpected(uri, charOffset, error),
                 charOffset)));
   }
 
+  @override
+  Expression buildCompileTimeError(Message message, int charOffset) {
+    // 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)
+    deprecated_addCompileTimeError(charOffset, message.message,
+        wasHandled: true);
+    return new KernelSyntheticExpression(library.loader
+        .throwCompileConstantError(library.loader
+            .deprecated_buildCompileTimeError(
+                deprecated_formatUnexpected(uri, charOffset, message.message),
+                charOffset)));
+  }
+
   Expression deprecated_wrapInCompileTimeError(
       Expression expression, String message) {
     return new Let(
         new VariableDeclaration.forValue(expression)
           ..fileOffset = expression.fileOffset,
         deprecated_buildCompileTimeError(message, expression.fileOffset))
       ..fileOffset = expression.fileOffset;
   }
 
   Expression buildFallThroughError(int charOffset) {
     deprecated_warningNotError(
         "Switch case may fall through to next case.", charOffset);
 
     Location location = messages.getLocationFromUri(uri, charOffset);
 
     return new Throw(buildStaticInvocation(
         library.loader.coreTypes.fallThroughErrorUrlAndLineConstructor,
         new Arguments(<Expression>[
           new StringLiteral(location?.file ?? uri.toString()),
           new IntLiteral(location?.line ?? 0)
         ]),
         charOffset: charOffset));
   }
 
   Expression buildAbstractClassInstantiationError(String className,
       [int charOffset = -1]) {
-    deprecated_warning(
-        "The class '$className' is abstract and can't be instantiated.",
+    warning(fasta.templateAbstractClassInstantiation.withArguments(className),
         charOffset);
     Builder constructor = library.loader.getAbstractClassInstantiationError();
     return new KernelSyntheticExpression(new Throw(buildStaticInvocation(
         constructor.target,
         new KernelArguments(<Expression>[new StringLiteral(className)]))));
   }
 
   Statement deprecated_buildCompileTimeErrorStatement(error,
       [int charOffset = -1]) {
     return new KernelExpressionStatement(
@@ skipping 127 matching lines @@
       deprecated_addCompileTimeError(charOffset, message);
     } else {
       super.deprecated_warning(message, charOffset);
     }
   }
 
   void deprecated_warningNotError(String message, [int charOffset = -1]) {
     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.";
       if (nonInstanceAccessIsError) {
         deprecated_addCompileTimeError(offset, message);
       } else {
         deprecated_warning(message, offset);
       }
@@ skipping 49 matching lines @@
             ..fileOffset = offset)
         ..fileOffset = offset;
     } else {
       return new KernelMethodInvocation(receiver, name, arguments,
           isImplicitCall: isImplicitCall)
         ..fileOffset = offset;
     }
   }
 
   @override
-  void addCompileTimeErrorFromMessage(FastaMessage message) {
-    library.deprecated_addCompileTimeError(message.charOffset, message.message,
-        fileUri: message.uri);
+  void addCompileTimeError(Message message, int charOffset) {
+    library.deprecated_addCompileTimeError(charOffset, message.message,
+        fileUri: uri);
   }
 
   @override
   void debugEvent(String name) {
     // printEvent(name);
   }
 
   @override
   StaticGet makeStaticGet(Member readTarget, Token token) {
     return new KernelStaticGet(readTarget)..fileOffset = offsetForToken(token);
@@ skipping 453 matching lines @@
     if (starToken == null) {
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return deprecated_internalProblem("Unknown async modifier: $asyncToken");
   }
 }