Remove deprecated_internalProblem.

pkg/front_end/lib/src/fasta/kernel/kernel_target.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.kernel_target;
 
 import 'dart:async' show Future;
 
-import 'package:front_end/file_system.dart';
-
 import 'package:kernel/ast.dart'
     show
         Arguments,
         CanonicalName,
         Class,
         Constructor,
         DartType,
         DynamicType,
         EmptyStatement,
         Expression,
@@ skipping 14 matching lines @@
         StringLiteral,
         SuperInitializer,
         Throw,
         TypeParameter,
         VariableDeclaration,
         VariableGet,
         VoidType;
 
 import 'package:kernel/type_algebra.dart' show substitute;
 
-import '../source/source_loader.dart' show SourceLoader;
+import '../../../file_system.dart' show FileSystem;
+
+import '../compiler_context.dart' show CompilerContext;
+
+import '../deprecated_problems.dart'
+    show
+        deprecated_formatUnexpected,
+        deprecated_InputError,
+        reportCrash,
+        resetCrashReporting;
+
+import '../dill/dill_target.dart' show DillTarget;
+
+import '../messages.dart' show LocatedMessage;
+
+import '../problems.dart' show unhandled;
 
 import '../source/source_class_builder.dart' show SourceClassBuilder;
 
+import '../source/source_loader.dart' show SourceLoader;
+
 import '../target_implementation.dart' show TargetImplementation;
 
 import '../translate_uri.dart' show TranslateUri;
 
-import '../dill/dill_target.dart' show DillTarget;
-
-import '../deprecated_problems.dart'
-    show
-        deprecated_formatUnexpected,
-        deprecated_InputError,
-        deprecated_internalProblem,
-        reportCrash,
-        resetCrashReporting;
-
-import '../messages.dart' show LocatedMessage;
-
 import '../util/relativize.dart' show relativizeUri;
 
-import '../compiler_context.dart' show CompilerContext;
-
 import 'kernel_builder.dart'
     show
         Builder,
         ClassBuilder,
         InvalidTypeBuilder,
         KernelClassBuilder,
         KernelLibraryBuilder,
         KernelNamedTypeBuilder,
         KernelProcedureBuilder,
         LibraryBuilder,
@@ skipping 67 matching lines @@
       }
     }
     return new KernelLibraryBuilder(uri, fileUri, loader, isPatch);
   }
 
   void forEachDirectSupertype(ClassBuilder cls, void f(NamedTypeBuilder type)) {
     TypeBuilder supertype = cls.supertype;
     if (supertype is NamedTypeBuilder) {
       f(supertype);
     } else if (supertype != null) {
-      deprecated_internalProblem("Unhandled: ${supertype.runtimeType}");
+      unhandled("${supertype.runtimeType}", "forEachDirectSupertype",
+          cls.charOffset, cls.fileUri);
     }
     if (cls.interfaces != null) {
       for (NamedTypeBuilder t in cls.interfaces) {
         f(t);
       }
     }
     if (cls.library.loader == loader &&
         // TODO(ahe): Implement DillClassBuilder.mixedInType and remove the
         // above check.
         cls.mixedInType != null) {
@@ skipping 252 matching lines @@
       /// >that is accessible to LM , C has an implicitly declared constructor
       /// >named q'i = [C/S]qi of the form q'i(ai1,...,aiki) :
       /// >super(ai1,...,aiki);.
       TypeDeclarationBuilder supertype = builder;
       while (supertype.isMixinApplication) {
         SourceClassBuilder named = supertype;
         TypeBuilder type = named.supertype;
         if (type is NamedTypeBuilder) {
           supertype = type.builder;
         } else {
-          deprecated_internalProblem("Unhandled: ${type.runtimeType}");
+          unhandled("${type.runtimeType}", "installDefaultConstructor",
+              builder.charOffset, builder.fileUri);
         }
       }
       if (supertype is KernelClassBuilder) {
         Map<TypeParameter, DartType> substitutionMap =
             computeKernelSubstitutionMap(
                 builder.getSubstitutionMap(supertype, builder.fileUri,
                     builder.charOffset, dynamicType),
                 builder.parent);
         if (supertype.cls.constructors.isEmpty) {
           builder.addSyntheticConstructor(makeDefaultConstructor());
         } else {
           for (Constructor constructor in supertype.cls.constructors) {
             builder.addSyntheticConstructor(makeMixinApplicationConstructor(
                 builder.cls.mixin, constructor, substitutionMap));
           }
         }
       } else if (supertype is InvalidTypeBuilder) {
         builder.addSyntheticConstructor(makeDefaultConstructor());
       } else {
-        deprecated_internalProblem("Unhandled: ${supertype.runtimeType}");
+        unhandled("${supertype.runtimeType}", "installDefaultConstructor",
+            builder.charOffset, builder.fileUri);
       }
     } else {
       /// >Iff no constructor is specified for a class C, it implicitly has a
       /// >default constructor C() : super() {}, unless C is class Object.
       // The superinitializer is installed below in [finishConstructors].
       builder.addSyntheticConstructor(makeDefaultConstructor());
     }
   }
 
   Map<TypeParameter, DartType> computeKernelSubstitutionMap(
@@ skipping 200 matching lines @@
   }
   for (Constructor constructor in superclass.constructors) {
     if (constructor.name.name.isEmpty) {
       return constructor.function.requiredParameterCount == 0
           ? constructor
           : null;
     }
   }
   return null;
 }