Remove all deprecated fasta message methods from analyzer.

pkg/analyzer/lib/src/fasta/element_store.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.analyzer.element_store;
 
 import 'package:analyzer/src/kernel/loader.dart' show ReferenceLevelLoader;
 
 import 'package:kernel/ast.dart';
 
 import 'package:analyzer/analyzer.dart' show ParameterKind;
 
 import 'package:analyzer/analyzer.dart' as analyzer;
 
 import 'package:analyzer/dart/element/element.dart';
 
 import 'package:analyzer/dart/element/type.dart' as analyzer;
 
-import 'package:front_end/src/fasta/deprecated_problems.dart'
-    show deprecated_internalProblem;
+import 'package:front_end/src/fasta/problems.dart' show unhandled, unsupported;
 
 import 'package:front_end/src/fasta/kernel/kernel_builder.dart';
 
 import 'package:front_end/src/fasta/dill/dill_member_builder.dart';
 
 import 'mock_element.dart';
 
 import 'mock_type.dart';
 
 abstract class ElementStore implements ReferenceLevelLoader {
@@ skipping 49 matching lines @@
         do {
           if (builder is ClassBuilder) {
             elements[builder] = new KernelClassElement(builder);
           } else if (builder is KernelFunctionTypeAliasBuilder) {
             elements[builder] = new KernelFunctionTypeAliasElement(builder);
           } else if (builder is DillMemberBuilder) {
             Member member = builder.member;
             if (member is Field) {} else if (member is Procedure) {
               buildDillFunctionElement(builder, unit, elements);
             } else {
-              deprecated_internalProblem(
-                  "Unhandled $name ${member.runtimeType} in $uri");
+              unhandled("'$name' (${member.runtimeType})", "element store",
+                  builder.charOffset, uri);
             }
           } else if (builder is KernelProcedureBuilder) {
             buildKernelFunctionElement(builder, unit, elements);
           } else if (builder is BuiltinTypeBuilder) {
             // TODO(ahe): Set up elements for dynamic and void.
           } else {
-            deprecated_internalProblem(
-                "Unhandled $name ${builder.runtimeType} in $uri");
+            unhandled("'$name' (${builder.runtimeType})", "element store",
+                builder.charOffset, uri);
           }
           builder = builder.next;
         } while (builder != null);
       });
     });
     return new ElementStoreImplementation.internal(coreLibrary, elements);
   }
 
   bool get ignoreRedirectingFactories => false;
 
   Constructor getCoreClassConstructorReference(String className,
       {String constructorName, String library}) {
     assert(library == null);
     return coreLibrary
         .getConstructor(className, constructorName: constructorName)
         .target;
   }
 
   Library getLibraryReference(LibraryElement element) {
-    return deprecated_internalProblem("not supported.");
+    return unsupported("getLibraryReference", -1, null);
   }
 
   Class getClassReference(covariant KernelClassElement cls) => cls.builder.cls;
 
   Member getMemberReference(Element element) {
     if (element is KernelFunctionElement) {
       return element.procedure;
     } else {
-      return deprecated_internalProblem(
-          "getMemberReference(${element.runtimeType})");
+      return unhandled(
+          "${element.runtimeType}", "getMemberReference", -1, null);
     }
   }
 
-  Class getRootClassReference() => deprecated_internalProblem("not supported.");
+  Class getRootClassReference() =>
+      unsupported("getRootClassReference", -1, null);
 
   Constructor getRootClassConstructorReference() {
-    return deprecated_internalProblem("not supported.");
+    return unsupported("getRootClassConstructorReference", -1, null);
   }
 
   Class getCoreClassReference(String className) {
-    return deprecated_internalProblem("not supported.");
+    return unsupported("getCoreClassReference", -1, null);
   }
 
   TypeParameter tryGetClassTypeParameter(TypeParameterElement element) {
-    return deprecated_internalProblem("not supported.");
+    return unsupported("tryGetClassTypeParameter", -1, null);
   }
 
   Class getSharedMixinApplicationClass(
       Library library, Class supertype, Class mixin) {
-    return deprecated_internalProblem("not supported.");
+    return unsupported("getSharedMixinApplicationClass", -1, null);
   }
 
   bool get strongMode => false;
 
   static void buildDillFunctionElement(DillMemberBuilder builder,
       KernelCompilationUnitElement unit, Map<Builder, Element> elements) {
     Procedure procedure = builder.member;
     List<VariableDeclaration> positionalParameters =
         procedure.function.positionalParameters;
     List<VariableDeclaration> namedParameters =
@@ skipping 97 matching lines @@
   String get name => variable.name.name;
 
   bool get isFinal => false; // TODO(ahe): implement this.
 
   bool get isConst => false; // TODO(ahe): implement this.
 
   analyzer.VariableDeclaration get target => variable;
 
   get type => null;
 
-  get constantValue => deprecated_internalProblem("not supported.");
+  get constantValue => unsupported("constantValue", charOffset, fileUri);
 
-  computeConstantValue() => deprecated_internalProblem("not supported.");
+  computeConstantValue() =>
+      unsupported("computeConstantValue", charOffset, fileUri);
 }
 
 /// Both an [Element] and [Builder] to using memory to store local elements in
 /// [ElementStore].
 class AnalyzerParameterElement extends MockParameterElement {
   final analyzer.FormalParameter parameter;
 
   AnalyzerParameterElement(this.parameter);
 
   String get name => parameter.identifier.name;
@@ skipping 15 matching lines @@
   }
 }
 
 class KernelFunctionTypeAliasElement extends MockFunctionTypeAliasElement {
   final KernelFunctionTypeAliasBuilder builder;
 
   KernelFunctionTypeAliasElement(this.builder);
 
   @override
   analyzer.DartType get returnType {
-    return deprecated_internalProblem("not supported.");
+    return unsupported("returnType", charOffset, fileUri);
   }
 
   @override
   analyzer.FunctionType get type {
-    return deprecated_internalProblem("not supported.");
+    return unsupported("type", charOffset, fileUri);
   }
 
   @override
   List<TypeParameterElement> get typeParameters {
-    return deprecated_internalProblem("not supported.");
+    return unsupported("typeParameters", charOffset, fileUri);
   }
 }
 
 class KernelInterfaceType extends MockInterfaceType {
   final KernelClassElement element;
 
   KernelInterfaceType(this.element);
 
   List<analyzer.DartType> get typeArguments => const <analyzer.DartType>[];
 }