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 BoundFastaMessage, FastaMessage;
+
+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;
+    BoundFastaMessage message;
     if (isGetter) {
-      message = "Getter not found: '$errorName'.";
+      message = fasta.codeGetterNotFound.bind(errorName);
     } else if (isSetter) {
-      message = "Setter not found: '$errorName'.";
+      message = fasta.codeSetterNotFound.bind(errorName);
     } else {
-      message = "Method not found: '$errorName'.";
+      message = fasta.codeMethodNotFound.bind(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);
     } 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.codeListLiteralTooManyTypeArguments, 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.codeListLiteralTypeArgumentMismatch, 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 30 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);
-      return const InvalidType();
+      return const DynamicType();
     } 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.");
     }
     if (builder.hasProblem) {
       ProblemBuilder problem = builder;
       deprecated_addCompileTimeError(charOffset, problem.deprecated_message);
     } else {
-      deprecated_warningNotError(
-          "Not a type: '${builder.fullNameForErrors}'.", charOffset);
+      warningNotError(
+          fasta.codeNotAType.bind(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.codeNotAType.bind(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.codeNonInstanceTypeVariableUse.
   }
 
   @override
   void beginFunctionType(Token beginToken) {
     debugEvent("beginFunctionType");
     enterFunctionTypeScope();
   }
 
   void enterFunctionTypeScope() {
     List typeVariables = pop();
@@ skipping 1296 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) {
     bool silent = hasParserError ||
-        message.code == codeFinalFieldWithoutInitializer ||
-        message.code == codeConstFieldWithoutInitializer;
+        message.code == fasta.codeFinalFieldWithoutInitializer ||
+        message.code == fasta.codeConstFieldWithoutInitializer;
     deprecated_addCompileTimeError(message.charOffset, message.message,
         silent: silent);
   }
 
   @override
   Token handleUnrecoverableError(Token token, FastaMessage message) {
-    if (enableNative && message.code == codeExpectedFunctionBody) {
+    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);
   }
 
@@ skipping 30 matching lines @@
         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.",
-        charOffset);
+    warning(fasta.codeAbstractClassInstantiation.bind(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(
         deprecated_buildCompileTimeError(error, charOffset));
@@ skipping 126 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(BoundFastaMessage bind, int charOffset) {
+    super.warning(bind, 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 525 matching lines @@
     if (starToken == null) {
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return deprecated_internalProblem("Unknown async modifier: $asyncToken");
   }
 }