Remove deprecated_internalProblem.

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:kernel/ast.dart'
     hide InvalidExpression, InvalidInitializer, InvalidStatement;
 
 import '../../scanner/token.dart' show Token;
 
-import '../deprecated_problems.dart' show deprecated_internalProblem;
-
 import '../messages.dart' show Message;
 
 import '../names.dart' show callName, lengthName;
 
-import '../scope.dart'
-    show deprecated_AccessErrorBuilder, ProblemBuilder, Scope;
+import '../problems.dart' show unhandled, unimplemented, unsupported;
+
+import '../scope.dart' show AccessErrorBuilder, ProblemBuilder, Scope;
 
 import '../type_inference/type_promotion.dart' show TypePromoter;
 
-import 'kernel_shadow_ast.dart'
-    show
-        KernelArguments,
-        KernelComplexAssignment,
-        KernelIllegalAssignment,
-        KernelIndexAssign,
-        KernelPropertyAssign,
-        KernelStaticAssignment,
-        KernelThisExpression,
-        KernelTypeLiteral,
-        KernelVariableAssignment;
-
-import 'utils.dart' show offsetForToken;
-
-import 'frontend_accessors.dart' show Accessor;
-
 import 'frontend_accessors.dart' as kernel
     show
         IndexAccessor,
         NullAwarePropertyAccessor,
         PropertyAccessor,
         ReadOnlyAccessor,
         StaticAccessor,
         SuperIndexAccessor,
         SuperPropertyAccessor,
         ThisIndexAccessor,
         ThisPropertyAccessor,
         VariableAccessor;
 
+import 'frontend_accessors.dart' show Accessor;
+
 import 'kernel_builder.dart'
     show
         Builder,
         KernelClassBuilder,
         KernelInvalidTypeBuilder,
         LibraryBuilder,
         PrefixBuilder,
         TypeDeclarationBuilder;
 
+import 'kernel_shadow_ast.dart'
+    show
+        KernelArguments,
+        KernelComplexAssignment,
+        KernelIllegalAssignment,
+        KernelIndexAssign,
+        KernelPropertyAssign,
+        KernelStaticAssignment,
+        KernelThisExpression,
+        KernelTypeLiteral,
+        KernelVariableAssignment;
+
+import 'utils.dart' show offsetForToken;
+
 abstract class BuilderHelper {
   LibraryBuilder get library;
 
   Uri get uri;
 
   TypePromoter get typePromoter;
 
   int get functionNestingLevel;
 
   bool get constantExpressionRequired;
@@ skipping 141 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 => deprecated_internalProblem("Unsupported operation.");
+  Name get name => unsupported("name", offsetForToken(token), uri);
 
   @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 =>
-      deprecated_internalProblem(isSuper ? "super" : "this");
+  String get plainNameForRead {
+    return unsupported("${isSuper ? 'super' : 'this'}.plainNameForRead",
+        offsetForToken(token), uri);
+  }
 
   Expression buildSimpleRead() {
     if (!isSuper) {
       return new KernelThisExpression();
     } else {
       return helper.deprecated_buildCompileTimeError(
           "Can't use `super` as an expression.", offsetForToken(token));
     }
   }
 
@@ skipping 148 matching lines @@
   @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() {

[Johnni Winther, 2017/07/11 18:34:05]

Here and many below: Should it be 'unhandled' instead of 'unsupported'?

[ahe, 2017/07/12 14:04:02]

Similar reasoning: I know now that this is unsupported as I have no crashes due
to these methods.

-    return deprecated_internalProblem("Unhandled");
+    return unsupported("buildSimpleRead", offsetForToken(token), uri);
   }
 
   Expression buildAssignment(Expression value, {bool voidContext: false}) {
-    return deprecated_internalProblem("Unhandled");
+    return unsupported("buildAssignment", offsetForToken(token), uri);
   }
 
   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.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 deprecated_internalProblem("Unhandled");
+    return unsupported("buildNullAwareAssignment", offset, uri);
   }
 
   Expression buildCompoundAssignment(Name binaryOperator, Expression value,
       {int offset,
       bool voidContext: false,
       Procedure interfaceTarget,
       bool isPreIncDec: false}) {
-    return deprecated_internalProblem("Unhandled");
+    return unsupported(
+        "buildCompoundAssignment", offset ?? offsetForToken(token), uri);
   }
 
   Expression buildPrefixIncrement(Name binaryOperator,
       {int offset, bool voidContext: false, Procedure interfaceTarget}) {
-    return deprecated_internalProblem("Unhandled");
+    return unsupported(
+        "buildPrefixIncrement", offset ?? offsetForToken(token), uri);
   }
 
   Expression buildPostfixIncrement(Name binaryOperator,
       {int offset, bool voidContext: false, Procedure interfaceTarget}) {
-    return deprecated_internalProblem("Unhandled");
+    return unsupported(
+        "buildPostfixIncrement", offset ?? offsetForToken(token), uri);
   }
 
   Expression doInvocation(int offset, Arguments arguments) {
-    return deprecated_internalProblem("Unhandled");
+    return unsupported("doInvocation", offset, uri);
   }
 
   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() => deprecated_internalProblem("Unhandled");
+  Expression buildSimpleRead() {
+    return unsupported("buildSimpleRead", offsetForToken(token), uri);
+  }
 
   Expression buildAssignment(Expression value, {bool voidContext: false}) {
-    return deprecated_internalProblem("Unhandled");
+    return unsupported("buildAssignment", offsetForToken(token), uri);
   }
 
   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.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 deprecated_internalProblem("Unhandled");
+    return unsupported("buildNullAwareAssignment", offset, uri);
   }
 
   Expression buildCompoundAssignment(Name binaryOperator, Expression value,
       {int offset,
       bool voidContext: false,
       Procedure interfaceTarget,
       bool isPreIncDec: false}) {
-    return deprecated_internalProblem("Unhandled");
+    return unsupported(
+        "buildCompoundAssignment", offset ?? offsetForToken(token), uri);
   }
 
   Expression buildPrefixIncrement(Name binaryOperator,
       {int offset, bool voidContext: false, Procedure interfaceTarget}) {
-    return deprecated_internalProblem("Unhandled");
+    return unsupported(
+        "buildPrefixIncrement", offset ?? offsetForToken(token), uri);
   }
 
   Expression buildPostfixIncrement(Name binaryOperator,
       {int offset, bool voidContext: false, Procedure interfaceTarget}) {
-    return deprecated_internalProblem("Unhandled");
+    return unsupported(
+        "buildPostfixIncrement", offset ?? offsetForToken(token), uri);
   }
 
   Expression doInvocation(int offset, Arguments arguments) {
-    return deprecated_internalProblem("Unhandled");
+    return unsupported("doInvocation", offset, uri);
   }
 
   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 deprecated_AccessErrorBuilder) {
-      deprecated_AccessErrorBuilder error = builder;
+    if (builder is AccessErrorBuilder) {
+      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 deprecated_internalProblem("Unhandled: ${builder}");
+      return unhandled("${builder.runtimeType}", "StaticAccessor.fromBuilder",
+          offsetForToken(token), helper.uri);
     }
     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);
   }
@@ skipping 41 matching lines @@
     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 deprecated_internalProblem(
-          "Unhandled invocation ${getter.runtimeType}.",
-          helper.uri,
-          offsetForToken(token));
+      return unhandled("${getter.runtimeType}", "doInvocation", offset, uri);
     }
   }
 
   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 deprecated_internalProblem("Not implemented yet.");
+    return unimplemented("doInvocation", offset, uri);
   }
 
   toString() => "NullAwarePropertyAccessor()";
 
   @override
   KernelComplexAssignment startComplexAssignment(Expression rhs) =>
       new KernelPropertyAssign(receiverExpression, rhs);
 }
 
 int adjustForImplicitCall(String name, int offset) {
@@ skipping 94 matching lines @@
     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
-        // [deprecated_AccessErrorBuilder], not null.
+        // [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);
 }