Remove deprecated_internalProblem.

pkg/front_end/lib/src/fasta/kernel/kernel_shadow_ast.dart

 // Copyright (c) 2017, 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.
 
 /// This file declares a "shadow hierarchy" of concrete classes which extend
 /// the kernel class hierarchy, adding methods and fields needed by the
 /// BodyBuilder.
 ///
 /// Instances of these classes may be created using the factory methods in
 /// `ast_factory.dart`.
@@ skipping 12 matching lines @@
 import 'package:front_end/src/fasta/type_inference/type_inference_listener.dart';
 import 'package:front_end/src/fasta/type_inference/type_inferrer.dart';
 import 'package:front_end/src/fasta/type_inference/type_promotion.dart';
 import 'package:front_end/src/fasta/type_inference/type_schema.dart';
 import 'package:front_end/src/fasta/type_inference/type_schema_elimination.dart';
 import 'package:kernel/ast.dart'
     hide InvalidExpression, InvalidInitializer, InvalidStatement;
 import 'package:kernel/frontend/accessors.dart';
 import 'package:kernel/type_environment.dart';
 
-import '../deprecated_problems.dart' show deprecated_internalProblem;
+import '../problems.dart' show unhandled, unsupported;
 
 /// Computes the return type of a (possibly factory) constructor.
 InterfaceType computeConstructorReturnType(Member constructor) {
   if (constructor is Constructor) {
     return constructor.enclosingClass.thisType;
   } else {
     return constructor.function.returnType;
   }
 }
 
@@ skipping 486 matching lines @@
     implements KernelExpression {
   KernelDirectMethodInvocation(
       Expression receiver, Procedure target, Arguments arguments)
       : super(receiver, target, arguments);
 
   @override
   void _collectDependencies(KernelDependencyCollector collector) {
     // DirectMethodInvocation can only occur as a result of a use of `super`,
     // and `super` can't appear inside a field initializer.  So this code should
     // never be reached.
-    deprecated_internalProblem(
-        'Unexpected call to _collectDependencies for DirectMethodInvocation');
+    unsupported(
+        "DirectMethodInvocation._collectDependencies", fileOffset, null);
   }
 
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     inferrer.instrumentation?.record(Uri.parse(inferrer.uri), fileOffset,
         'target', new InstrumentationValueForMember(target));
     return inferrer.inferMethodInvocation(
         this, receiver, fileOffset, false, typeContext, typeNeeded,
         interfaceMember: target, methodName: target.name, arguments: arguments);
   }
 }
 
 /// Shadow object for [DirectPropertyGet].
 class KernelDirectPropertyGet extends DirectPropertyGet
     implements KernelExpression {
   KernelDirectPropertyGet(Expression receiver, Member target)
       : super(receiver, target);
 
   @override
   void _collectDependencies(KernelDependencyCollector collector) {
     // DirectPropertyGet can only occur as a result of a use of `super`, and
     // `super` can't appear inside a field initializer.  So this code should
     // never be reached.
-    deprecated_internalProblem(
-        'Unexpected call to _collectDependencies for DirectPropertyGet');
+    unsupported("DirectPropertyGet._collectDependencies", fileOffset, null);
   }
 
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     return inferrer.inferPropertyGet(
         this, receiver, fileOffset, typeContext, typeNeeded,
         propertyName: target.name);
   }
 }
@@ skipping 866 matching lines @@
         var parameter = function.positionalParameters[0];
         engine.instrumentation?.record(Uri.parse(uri), parameter.fileOffset,
             'topType', new InstrumentationValueForType(inferredType));
         parameter.type = inferredType;
       }
     } else if (isGetter) {
       engine.instrumentation?.record(Uri.parse(uri), fileOffset, 'topType',
           new InstrumentationValueForType(inferredType));
       function.returnType = inferredType;
     } else {
-      deprecated_internalProblem(
-          'setInferredType called on a procedure that is not an accessor');
+      unhandled("setInferredType", "not accessor", fileOffset, Uri.parse(uri));
     }
   }
 
   static MethodNode getMethodNode(Procedure procedure) {
     if (procedure is KernelProcedure) return procedure._methodNode;
     return null;
   }
 
   static bool hasImplicitReturnType(KernelProcedure procedure) {
     return procedure._hasImplicitReturnType;
@@ skipping 939 matching lines @@
               ? inferrer.coreTypes.streamClass
               : inferrer.coreTypes.iterableClass);
     }
     var inferredType = inferrer.inferExpression(expression, typeContext, true);
     closureContext.handleYield(inferrer, isYieldStar, inferredType);
     inferrer.listener.yieldStatementExit(this);
   }
 }
 
 class _UnfinishedCascade extends Expression {
-  accept(v) {
-    return deprecated_internalProblem("Internal error: Unsupported operation.");
-  }
+  accept(v) => unsupported("accept", -1, null);
 
-  accept1(v, arg) {
-    return deprecated_internalProblem("Internal error: Unsupported operation.");
-  }
+  accept1(v, arg) => unsupported("accept1", -1, null);
 
-  getStaticType(types) {
-    return deprecated_internalProblem("Internal error: Unsupported operation.");
-  }
+  getStaticType(types) => unsupported("getStaticType", -1, null);
 
-  transformChildren(v) {
-    return deprecated_internalProblem("Internal error: Unsupported operation.");
-  }
+  transformChildren(v) => unsupported("transformChildren", -1, null);
 
-  visitChildren(v) {
-    return deprecated_internalProblem("Internal error: Unsupported operation.");
-  }
+  visitChildren(v) => unsupported("visitChildren", -1, null);
 }