Deprecate all diagnostics methods that use strings.

pkg/front_end/lib/src/fasta/kernel/fasta_accessors.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.fasta_accessors;
 
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart'
     show
         KernelArguments,
         KernelComplexAssignment,
@@ skipping 10 matching lines @@
 import 'package:front_end/src/scanner/token.dart' show Token;
 
 import 'frontend_accessors.dart' show Accessor;
 
 import 'package:front_end/src/fasta/type_inference/type_promotion.dart'
     show TypePromoter;
 
 import 'package:kernel/ast.dart'
     hide InvalidExpression, InvalidInitializer, InvalidStatement;
 
-import '../errors.dart' show internalError;
+import '../deprecated_problems.dart' show deprecated_internalProblem;
 
-import '../scope.dart' show AccessErrorBuilder, ProblemBuilder, Scope;
+import '../scope.dart'
+    show deprecated_AccessErrorBuilder, ProblemBuilder, Scope;
 
 import 'frontend_accessors.dart' as kernel
     show
         IndexAccessor,
         NullAwarePropertyAccessor,
         PropertyAccessor,
         ReadOnlyAccessor,
         StaticAccessor,
         SuperIndexAccessor,
         SuperPropertyAccessor,
@@ skipping 29 matching lines @@
 
   Expression toValue(node);
 
   Member lookupSuperMember(Name name, {bool isSetter});
 
   scopeLookup(Scope scope, String name, Token token,
       {bool isQualified: false, PrefixBuilder prefix});
 
   finishSend(Object receiver, Arguments arguments, int offset);
 
-  Expression buildCompileTimeError(error, [int offset]);
+  Expression deprecated_buildCompileTimeError(error, [int offset]);
 
   Initializer buildInvalidInitializer(Expression expression, [int offset]);
 
   Initializer buildFieldInitializer(
       String name, int offset, Expression expression);
 
   Initializer buildSuperInitializer(
       Constructor constructor, Arguments arguments,
       [int offset]);
 
   Initializer buildRedirectingInitializer(
       Constructor constructor, Arguments arguments,
       [int charOffset = -1]);
 
   Expression buildStaticInvocation(Procedure target, Arguments arguments);
 
   Expression buildProblemExpression(ProblemBuilder builder, int offset);
 
   Expression throwNoSuchMethodError(
       Expression receiver, String name, Arguments arguments, int offset,
       {bool isSuper, bool isGetter, bool isSetter, bool isStatic});
 
   bool checkArguments(FunctionNode function, Arguments arguments,
       List<TypeParameter> typeParameters);
 
   StaticGet makeStaticGet(Member readTarget, Token token);
 
-  dynamic addCompileTimeError(int charOffset, String message, {bool silent});
+  dynamic deprecated_addCompileTimeError(int charOffset, String message,
+      {bool silent});
 
   bool isIdentical(Member member);
 
   Expression buildMethodInvocation(
       Expression receiver, Name name, Arguments arguments, int offset,
       {bool isConstantExpression, bool isNullAware, bool isImplicitCall});
 
   DartType validatedTypeVariableUse(
       TypeParameterType type, int offset, bool nonInstanceAccessIsError);
 
-  void warning(String message, [int charOffset]);
+  void deprecated_warning(String message, [int charOffset]);
 
   void warnUnresolvedSuperGet(Name name, int charOffset);
 
   void warnUnresolvedSuperSet(Name name, int charOffset);
 
   void warnUnresolvedSuperMethod(Name name, int charOffset);
 }
 
 abstract class FastaAccessor implements Accessor {
   BuilderHelper get helper;
 
   String get plainNameForRead;
 
   Uri get uri => helper.uri;
 
   String get plainNameForWrite => plainNameForRead;
 
   bool get isInitializer => false;
 
   Expression buildForEffect() => buildSimpleRead();
 
   Initializer buildFieldInitializer(Map<String, int> initializedFields) {
     int offset = offsetForToken(token);
     return helper.buildInvalidInitializer(
-        helper.buildCompileTimeError(
+        helper.deprecated_buildCompileTimeError(
             // TODO(ahe): This error message is really bad.
             "Can't use $plainNameForRead here.",
             offset),
         offset);
   }
 
   Expression makeInvalidRead() {
     return buildThrowNoSuchMethodError(
         new NullLiteral()..fileOffset = offsetForToken(token),
         new Arguments.empty(),
@@ skipping 11 matching lines @@
       int offset, Arguments arguments);
 
   /* Expression | FastaAccessor */ buildPropertyAccess(
       IncompleteSend send, int operatorOffset, bool isNullAware) {
     if (send is SendAccessor) {
       return helper.buildMethodInvocation(buildSimpleRead(), send.name,
           send.arguments, offsetForToken(send.token),
           isNullAware: isNullAware);
     } else {
       if (helper.constantExpressionRequired && send.name != lengthName) {
-        helper.addCompileTimeError(
+        helper.deprecated_addCompileTimeError(
             offsetForToken(token), "Not a constant expression.");
       }
       return PropertyAccessor.make(helper, send.token, buildSimpleRead(),
           send.name, null, null, isNullAware);
     }
   }
 
   /* Expression | FastaAccessor */ buildThrowNoSuchMethodError(
       Expression receiver, Arguments arguments,
       {bool isSuper: false,
@@ skipping 17 matching lines @@
       new KernelIllegalAssignment(rhs);
 }
 
 abstract class ErrorAccessor implements FastaAccessor {
   /// Pass [arguments] that must be evaluated before throwing an error.  At
   /// most one of [isGetter] and [isSetter] should be true and they're passed
   /// to [BuilderHelper.buildThrowNoSuchMethodError] if it is used.
   Expression buildError(Arguments arguments,
       {bool isGetter: false, bool isSetter: false, int offset});
 
-  Name get name => internalError("Unsupported operation.");
+  Name get name => deprecated_internalProblem("Unsupported operation.");
 
   @override
   String get plainNameForRead => name.name;
 
   withReceiver(Object receiver, int operatorOffset, {bool isNullAware}) => this;
 
   @override
   Initializer buildFieldInitializer(Map<String, int> initializedFields) {
     return helper.buildInvalidInitializer(
         buildError(new Arguments.empty(), isSetter: true));
@@ skipping 79 matching lines @@
 
   final Token token;
 
   final bool isInitializer;
 
   final bool isSuper;
 
   ThisAccessor(this.helper, this.token, this.isInitializer,
       {this.isSuper: false});
 
-  String get plainNameForRead => internalError(isSuper ? "super" : "this");
+  String get plainNameForRead =>
+      deprecated_internalProblem(isSuper ? "super" : "this");
 
   Expression buildSimpleRead() {
     if (!isSuper) {
       return new KernelThisExpression();
     } else {
-      return helper.buildCompileTimeError(
+      return helper.deprecated_buildCompileTimeError(
           "Can't use `super` as an expression.", offsetForToken(token));
     }
   }
 
   @override
   Initializer buildFieldInitializer(Map<String, int> initializedFields) {
     String keyword = isSuper ? "super" : "this";
     int offset = offsetForToken(token);
     return helper.buildInvalidInitializer(
-        helper.buildCompileTimeError(
+        helper.deprecated_buildCompileTimeError(
             "Can't use '$keyword' here, did you mean '$keyword()'?", offset),
         offset);
   }
 
   buildPropertyAccess(
       IncompleteSend send, int operatorOffset, bool isNullAware) {
     if (isInitializer && send is SendAccessor) {
       if (isNullAware) {
-        helper.addCompileTimeError(
+        helper.deprecated_addCompileTimeError(
             operatorOffset, "Expected '.'\nTry removing '?'.");
       }
       return buildConstructorInitializer(
           offsetForToken(send.token), send.name, send.arguments);
     }
     if (send is SendAccessor) {
       // Notice that 'this' or 'super' can't be null. So we can ignore the
       // value of [isNullAware].
       MethodInvocation result = helper.buildMethodInvocation(
           new KernelThisExpression(),
@@ skipping 70 matching lines @@
   Expression buildPostfixIncrement(Name binaryOperator,
       {int offset: TreeNode.noOffset,
       bool voidContext: false,
       Procedure interfaceTarget}) {
     return buildAssignmentError();
   }
 
   Expression buildAssignmentError() {
     String message =
         isSuper ? "Can't assign to 'super'." : "Can't assign to 'this'.";
-    return helper.buildCompileTimeError(message, offsetForToken(token));
+    return helper.deprecated_buildCompileTimeError(
+        message, offsetForToken(token));
   }
 
   toString() {
     int offset = offsetForToken(token);
     return "ThisAccessor($offset${isSuper ? ', super' : ''})";
   }
 }
 
 abstract class IncompleteSend extends FastaAccessor {
   final BuilderHelper helper;
 
   @override
   final Token token;
 
   final Name name;
 
   IncompleteSend(this.helper, this.token, this.name);
 
   withReceiver(Object receiver, int operatorOffset, {bool isNullAware});
 
   Arguments get arguments => null;
 }
 
-class IncompleteError extends IncompleteSend with ErrorAccessor {
+class deprecated_IncompleteError extends IncompleteSend with ErrorAccessor {
   final Object error;
 
-  IncompleteError(BuilderHelper helper, Token token, this.error)
+  deprecated_IncompleteError(BuilderHelper helper, Token token, this.error)
       : super(helper, token, null);
 
   @override
   Expression buildError(Arguments arguments,
       {bool isGetter: false, bool isSetter: false, int offset}) {
-    return helper.buildCompileTimeError(
+    return helper.deprecated_buildCompileTimeError(
         error, offset ?? offsetForToken(this.token));
   }
 
   @override
   doInvocation(int offset, Arguments arguments) => this;
 }
 
 class SendAccessor extends IncompleteSend {
   @override
   final Arguments arguments;
 
   SendAccessor(BuilderHelper helper, Token token, Name name, this.arguments)
       : super(helper, token, name) {
     assert(arguments != null);
   }
 
   String get plainNameForRead => name.name;
 
   Expression buildSimpleRead() {
-    return internalError("Unhandled");
+    return deprecated_internalProblem("Unhandled");
   }
 
   Expression buildAssignment(Expression value, {bool voidContext: false}) {
-    return internalError("Unhandled");
+    return deprecated_internalProblem("Unhandled");
   }
 
   withReceiver(Object receiver, int operatorOffset, {bool isNullAware: false}) {
     if (receiver is FastaAccessor) {
       return receiver.buildPropertyAccess(this, operatorOffset, isNullAware);
     }
     if (receiver is PrefixBuilder) {
       PrefixBuilder prefix = receiver;
       if (isNullAware) {
-        helper.addCompileTimeError(
+        helper.deprecated_addCompileTimeError(
             offsetForToken(token),
             "Library prefix '${prefix.name}' can't be used with null-aware "
             "operator.\nTry removing '?'.");
       }
       receiver = helper.scopeLookup(prefix.exports, name.name, token,
           isQualified: true, prefix: prefix);
       return helper.finishSend(receiver, arguments, offsetForToken(token));
     }
     return helper.buildMethodInvocation(
         helper.toValue(receiver), name, arguments, offsetForToken(token),
         isNullAware: isNullAware);
   }
 
   Expression buildNullAwareAssignment(
       Expression value, DartType type, int offset,
       {bool voidContext: false}) {
-    return internalError("Unhandled");
+    return deprecated_internalProblem("Unhandled");
   }
 
   Expression buildCompoundAssignment(Name binaryOperator, Expression value,
       {int offset,
       bool voidContext: false,
       Procedure interfaceTarget,
       bool isPreIncDec: false}) {
-    return internalError("Unhandled");
+    return deprecated_internalProblem("Unhandled");
   }
 
   Expression buildPrefixIncrement(Name binaryOperator,
       {int offset, bool voidContext: false, Procedure interfaceTarget}) {
-    return internalError("Unhandled");
+    return deprecated_internalProblem("Unhandled");
   }
 
   Expression buildPostfixIncrement(Name binaryOperator,
       {int offset, bool voidContext: false, Procedure interfaceTarget}) {
-    return internalError("Unhandled");
+    return deprecated_internalProblem("Unhandled");
   }
 
   Expression doInvocation(int offset, Arguments arguments) {
-    return internalError("Unhandled");
+    return deprecated_internalProblem("Unhandled");
   }
 
   toString() {
     int offset = offsetForToken(token);
     return "SendAccessor($offset, $name, $arguments)";
   }
 }
 
 class IncompletePropertyAccessor extends IncompleteSend {
   IncompletePropertyAccessor(BuilderHelper helper, Token token, Name name)
       : super(helper, token, name);
 
   String get plainNameForRead => name.name;
 
-  Expression buildSimpleRead() => internalError("Unhandled");
+  Expression buildSimpleRead() => deprecated_internalProblem("Unhandled");
 
   Expression buildAssignment(Expression value, {bool voidContext: false}) {
-    return internalError("Unhandled");
+    return deprecated_internalProblem("Unhandled");
   }
 
   withReceiver(Object receiver, int operatorOffset, {bool isNullAware: false}) {
     if (receiver is FastaAccessor) {
       return receiver.buildPropertyAccess(this, operatorOffset, isNullAware);
     }
     if (receiver is PrefixBuilder) {
       PrefixBuilder prefix = receiver;
       if (isNullAware) {
-        helper.addCompileTimeError(
+        helper.deprecated_addCompileTimeError(
             offsetForToken(token),
             "Library prefix '${prefix.name}' can't be used with null-aware "
             "operator.\nTry removing '?'.");
       }
       return helper.scopeLookup(prefix.exports, name.name, token,
           isQualified: true, prefix: prefix);
     }
 
     return PropertyAccessor.make(
         helper, token, helper.toValue(receiver), name, null, null, isNullAware);
   }
 
   Expression buildNullAwareAssignment(
       Expression value, DartType type, int offset,
       {bool voidContext: false}) {
-    return internalError("Unhandled");
+    return deprecated_internalProblem("Unhandled");
   }
 
   Expression buildCompoundAssignment(Name binaryOperator, Expression value,
       {int offset,
       bool voidContext: false,
       Procedure interfaceTarget,
       bool isPreIncDec: false}) {
-    return internalError("Unhandled");
+    return deprecated_internalProblem("Unhandled");
   }
 
   Expression buildPrefixIncrement(Name binaryOperator,
       {int offset, bool voidContext: false, Procedure interfaceTarget}) {
-    return internalError("Unhandled");
+    return deprecated_internalProblem("Unhandled");
   }
 
   Expression buildPostfixIncrement(Name binaryOperator,
       {int offset, bool voidContext: false, Procedure interfaceTarget}) {
-    return internalError("Unhandled");
+    return deprecated_internalProblem("Unhandled");
   }
 
   Expression doInvocation(int offset, Arguments arguments) {
-    return internalError("Unhandled");
+    return deprecated_internalProblem("Unhandled");
   }
 
   toString() {
     int offset = offsetForToken(token);
     return "IncompletePropertyAccessor($offset, $name)";
   }
 }
 
 class IndexAccessor extends kernel.IndexAccessor with FastaAccessor {
   final BuilderHelper helper;
@@ skipping 77 matching lines @@
 
 class StaticAccessor extends kernel.StaticAccessor with FastaAccessor {
   StaticAccessor(
       BuilderHelper helper, Token token, Member readTarget, Member writeTarget)
       : super(helper, readTarget, writeTarget, token) {
     assert(readTarget != null || writeTarget != null);
   }
 
   factory StaticAccessor.fromBuilder(BuilderHelper helper, Builder builder,
       Token token, Builder builderSetter) {
-    if (builder is AccessErrorBuilder) {
-      AccessErrorBuilder error = builder;
+    if (builder is deprecated_AccessErrorBuilder) {
+      deprecated_AccessErrorBuilder error = builder;
       builder = error.builder;
       // We should only see an access error here if we've looked up a setter
       // when not explicitly looking for a setter.
       assert(builder.isSetter);
     } else if (builder.target == null) {
-      return internalError("Unhandled: ${builder}");
+      return deprecated_internalProblem("Unhandled: ${builder}");
     }
     Member getter = builder.target.hasGetter ? builder.target : null;
     Member setter = builder.target.hasSetter ? builder.target : null;
     if (setter == null) {
       if (builderSetter?.target?.hasSetter ?? false) {
         setter = builderSetter.target;
       }
     }
     return new StaticAccessor(helper, token, getter, setter);
   }
 
   String get plainNameForRead => (readTarget ?? writeTarget).name.name;
 
   Expression doInvocation(int offset, Arguments arguments) {
     if (helper.constantExpressionRequired && !helper.isIdentical(readTarget)) {
-      helper.addCompileTimeError(offset, "Not a constant expression.");
+      helper.deprecated_addCompileTimeError(
+          offset, "Not a constant expression.");
     }
     if (readTarget == null || isFieldOrGetter(readTarget)) {
       return helper.buildMethodInvocation(buildSimpleRead(), callName,
           arguments, offset + (readTarget?.name?.name?.length ?? 0),
           // This isn't a constant expression, but we have checked if a
           // constant expression error should be emitted already.
           isConstantExpression: true,
           isImplicitCall: true);
     } else {
       return helper.buildStaticInvocation(readTarget, arguments)
@@ skipping 11 matching lines @@
 class SuperPropertyAccessor extends kernel.SuperPropertyAccessor
     with FastaAccessor {
   SuperPropertyAccessor(BuilderHelper helper, Token token, Name name,
       Member getter, Member setter)
       : super(helper, name, getter, setter, token);
 
   String get plainNameForRead => name.name;
 
   Expression doInvocation(int offset, Arguments arguments) {
     if (helper.constantExpressionRequired) {
-      helper.addCompileTimeError(offset, "Not a constant expression.");
+      helper.deprecated_addCompileTimeError(
+          offset, "Not a constant expression.");
     }
     if (getter == null || isFieldOrGetter(getter)) {
       return helper.buildMethodInvocation(
           buildSimpleRead(), callName, arguments, offset,
           // This isn't a constant expression, but we have checked if a
           // constant expression error should be emitted already.
           isConstantExpression: true,
           isImplicitCall: true);
     } else {
       // TODO(ahe): This could be something like "super.property(...)" where
       // property is a setter.
-      return internalError("Unhandled invocation ${getter.runtimeType}.",
-          helper.uri, offsetForToken(token));
+      return deprecated_internalProblem(
+          "Unhandled invocation ${getter.runtimeType}.",
+          helper.uri,
+          offsetForToken(token));
     }
   }
 
   toString() => "SuperPropertyAccessor()";
 
   @override
   KernelComplexAssignment startComplexAssignment(Expression rhs) =>
       new KernelPropertyAssign(null, rhs, isSuper: true);
 }
 
@@ skipping 75 matching lines @@
     with FastaAccessor {
   final BuilderHelper helper;
 
   NullAwarePropertyAccessor(this.helper, Token token, Expression receiver,
       Name name, Member getter, Member setter, DartType type)
       : super(helper, receiver, name, getter, setter, type, token);
 
   String get plainNameForRead => name.name;
 
   Expression doInvocation(int offset, Arguments arguments) {
-    return internalError("Not implemented yet.");
+    return deprecated_internalProblem("Not implemented yet.");
   }
 
   toString() => "NullAwarePropertyAccessor()";
 
   @override
   KernelComplexAssignment startComplexAssignment(Expression rhs) =>
       new KernelPropertyAssign(receiverExpression, rhs);
 }
 
 int adjustForImplicitCall(String name, int offset) {
@@ skipping 36 matching lines @@
         isImplicitCall: true);
   }
 }
 
 class ParenthesizedExpression extends ReadOnlyAccessor {
   ParenthesizedExpression(
       BuilderHelper helper, Expression expression, Token token)
       : super(helper, expression, null, token);
 
   Expression makeInvalidWrite(Expression value) {
-    return helper.buildCompileTimeError(
+    return helper.deprecated_buildCompileTimeError(
         "Can't assign to a parenthesized expression.", offsetForToken(token));
   }
 }
 
 class TypeDeclarationAccessor extends ReadOnlyAccessor {
   final TypeDeclarationBuilder declaration;
 
   TypeDeclarationAccessor(BuilderHelper helper, this.declaration,
       String plainNameForRead, Token token)
       : super(helper, null, plainNameForRead, token);
 
   Expression get expression {
     if (super.expression == null) {
       int offset = offsetForToken(token);
       if (declaration is KernelInvalidTypeBuilder) {
         KernelInvalidTypeBuilder declaration = this.declaration;
         String message = declaration.message;
-        helper.library.addWarning(declaration.charOffset, message,
+        helper.library.deprecated_addWarning(declaration.charOffset, message,
             fileUri: declaration.fileUri);
-        helper.warning(message, offset);
+        helper.deprecated_warning(message, offset);
         super.expression = new Throw(
             new StringLiteral(message)..fileOffset = offsetForToken(token))
           ..fileOffset = offset;
       } else {
         super.expression = new KernelTypeLiteral(
             buildType(null, nonInstanceAccessIsError: true))
           ..fileOffset = offsetForToken(token);
       }
     }
     return super.expression;
@@ skipping 16 matching lines @@
     Name name = send.name;
     Arguments arguments = send.arguments;
 
     if (declaration is KernelClassBuilder) {
       KernelClassBuilder declaration = this.declaration;
       Builder builder = declaration.findStaticBuilder(
           name.name, offsetForToken(token), uri, helper.library);
 
       FastaAccessor accessor;
       if (builder == null) {
-        // If we find a setter, [builder] is an [AccessErrorBuilder], not null.
+        // If we find a setter, [builder] is an
+        // [deprecated_AccessErrorBuilder], not null.
         accessor = new UnresolvedAccessor(helper, name, token);
       } else {
         Builder setter;
         if (builder.isSetter) {
           setter = builder;
         } else if (builder.isGetter) {
           setter = declaration.findStaticBuilder(
               name.name, offsetForToken(token), uri, helper.library,
               isSetter: true);
         } else if (builder.isField && !builder.isFinal) {
@@ skipping 45 matching lines @@
     offset ??= offsetForToken(this.token);
     return helper.throwNoSuchMethodError(new NullLiteral()..fileOffset = offset,
         plainNameForRead, arguments, offset,
         isGetter: isGetter, isSetter: isSetter);
   }
 }
 
 bool isFieldOrGetter(Member member) {
   return member is Field || (member is Procedure && member.isGetter);
 }