Remove all deprecated fasta message methods from analyzer.

pkg/analyzer/lib/src/fasta/ast_builder.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.ast_builder;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast_factory.dart' show AstFactory;
 import 'package:analyzer/dart/ast/standard_ast_factory.dart' as standard;
 import 'package:analyzer/dart/ast/token.dart' as analyzer show Token;
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
 import 'package:analyzer/dart/element/element.dart' show Element;
 import 'package:front_end/src/fasta/parser/parser.dart'
     show Assert, FormalParameterType, MemberKind, Parser;
 import 'package:front_end/src/fasta/scanner/string_scanner.dart';
 import 'package:front_end/src/fasta/scanner/token.dart' show CommentToken;
 import 'package:front_end/src/scanner/token.dart' as analyzer;
 
-import 'package:front_end/src/fasta/deprecated_problems.dart'
-    show deprecated_internalProblem;
+import 'package:front_end/src/fasta/problems.dart' show unexpected, unhandled;
 import 'package:front_end/src/fasta/messages.dart'
     show Code, Message, codeExpectedExpression, codeExpectedFunctionBody;
 import 'package:front_end/src/fasta/kernel/kernel_builder.dart'
     show Builder, KernelLibraryBuilder, ProcedureBuilder, Scope;
 import 'package:front_end/src/fasta/parser/identifier_context.dart'
     show IdentifierContext;
 import 'package:front_end/src/fasta/quote.dart';
 import 'package:front_end/src/fasta/source/scope_listener.dart'
     show JumpTargetKind, NullValue, ScopeListener;
 import 'analyzer.dart' show toKernel;
@@ skipping 126 matching lines @@
       List<InterpolationElement> elements = <InterpolationElement>[];
       elements.add(ast.interpolationString(
           first, unescapeFirstStringPart(first.lexeme, quote)));
       for (int i = 1; i < parts.length - 1; i++) {
         var part = parts[i];
         if (part is Token) {
           elements.add(ast.interpolationString(part, part.lexeme));
         } else if (part is Expression) {
           elements.add(ast.interpolationExpression(null, part, null));
         } else {
-          deprecated_internalProblem(
-              "Unexpected part in string interpolation: ${part.runtimeType}");
+          unhandled("${part.runtimeType}", "string interpolation",
+              first.charOffset, uri);
         }
       }
       elements.add(ast.interpolationString(
           last, unescapeLastStringPart(last.lexeme, quote)));
       push(ast.stringInterpolation(elements));
     }
   }
 
   void handleScript(Token token) {
     debugEvent("Script");
@@ skipping 118 matching lines @@
     } else if (body is ExpressionFunctionBody) {
       bodyStatement = ast.returnStatement(null, body.expression, null);
     } else {
       bodyStatement = (body as BlockFunctionBody).block;
     }
     var kernel = toKernel(bodyStatement, elementStore, library.library, scope);
     if (member is ProcedureBuilder) {
       ProcedureBuilder builder = member;
       builder.body = kernel;
     } else {
-      deprecated_internalProblem(
-          "Internal error: expected procedure, but got: $member");
+      unexpected("procedure", "${member.runtimeType}", member.charOffset, uri);
     }
   }
 
   void beginCascade(Token token) {
     debugEvent("beginCascade");
     Expression expression = pop();
     push(token);
     if (expression is CascadeExpression) {
       push(expression);
     } else {
@@ skipping 43 matching lines @@
       } else {
         push(ast.propertyAccess(receiver, token, identifierOrInvoke));
       }
     } else if (identifierOrInvoke is MethodInvocation) {
       assert(identifierOrInvoke.target == null);
       identifierOrInvoke
         ..target = receiver
         ..operator = token;
       push(identifierOrInvoke);
     } else {
-      deprecated_internalProblem(
-          "Unhandled property access: ${identifierOrInvoke.runtimeType}");
+      unhandled("${identifierOrInvoke.runtimeType}", "property access",
+          token.charOffset, uri);
     }
   }
 
   void handleLiteralInt(Token token) {
     debugEvent("LiteralInt");
     push(ast.integerLiteral(token, int.parse(token.lexeme)));
   }
 
   void handleExpressionFunctionBody(Token arrowToken, Token endToken) {
     debugEvent("ExpressionFunctionBody");
@@ skipping 128 matching lines @@
     VariableDeclaration variable;
     // TODO(paulberry): This seems kludgy.  It would be preferable if we
     // could respond to a "handleNoVariableInitializer" event by converting a
     // SimpleIdentifier into a VariableDeclaration, and then when this code was
     // reached, node would always be a VariableDeclaration.
     if (node is VariableDeclaration) {
       variable = node;
     } else if (node is SimpleIdentifier) {
       variable = ast.variableDeclaration(node, null, null);
     } else {
-      deprecated_internalProblem("unhandled identifier: ${node.runtimeType}");
+      unhandled("${node.runtimeType}", "identifier", nameToken.charOffset, uri);
     }
     push(variable);
     scope.declare(
         variable.name.name,
         variable.name.staticElement =
             new AnalyzerLocalVariableElemment(variable),
         nameToken.charOffset,
         uri);
   }
 
@@ skipping 649 matching lines @@
     var declarations = <CompilationUnitMember>[];
     if (elements != null) {
       for (AstNode node in elements) {
         if (node is ScriptTag) {
           scriptTag = node;
         } else if (node is Directive) {
           directives.add(node);
         } else if (node is CompilationUnitMember) {
           declarations.add(node);
         } else {
-          deprecated_internalProblem(
-              'Unrecognized compilation unit member: ${node.runtimeType}');
+          unhandled(
+              "${node.runtimeType}", "compilation unit", node.offset, uri);
         }
       }
     }
 
     push(ast.compilationUnit(
         beginToken, scriptTag, directives, declarations, endToken));
   }
 
   void endImport(Token importKeyword, Token deferredKeyword, Token asKeyword,
       Token semicolon) {
@@ skipping 140 matching lines @@
     WithClause withClause;
     var supertype = pop();
     if (supertype == null) {
       // No extends clause
     } else if (supertype is TypeName) {
       extendsClause = ast.extendsClause(extendsKeyword, supertype);
     } else if (supertype is _MixinApplication) {
       extendsClause = ast.extendsClause(extendsKeyword, supertype.supertype);
       withClause = ast.withClause(supertype.withKeyword, supertype.mixinTypes);
     } else {
-      deprecated_internalProblem(
-          'Unexpected kind of supertype ${supertype.runtimeType}');
+      unhandled("${supertype.runtimeType}", "supertype",
+          extendsKeyword.charOffset, uri);
     }
     TypeParameterList typeParameters = pop();
     SimpleIdentifier name = pop();
     assert(className == name.name);
     className = null;
     _Modifiers modifiers = pop();
     Token abstractKeyword = modifiers?.abstractKeyword;
     List<Annotation> metadata = pop();
     Comment comment = pop();
     push(ast.classDeclaration(
@@ skipping 142 matching lines @@
     Token separator;
     ConstructorName redirectedConstructor;
     Object bodyObject = pop();
     if (bodyObject is FunctionBody) {
       body = bodyObject;
     } else if (bodyObject is _RedirectingFactoryBody) {
       separator = bodyObject.equalToken;
       redirectedConstructor = bodyObject.constructorName;
       body = ast.emptyFunctionBody(semicolon);
     } else {
-      deprecated_internalProblem(
-          'Unexpected body object: ${bodyObject.runtimeType}');
+      unhandled("${bodyObject.runtimeType}", "bodyObject",
+          beginToken.charOffset, uri);
     }
 
     FormalParameterList parameters = pop();
     ConstructorName constructorName = pop();
     _Modifiers modifiers = pop();
     List<Annotation> metadata = pop();
     Comment comment = pop();
 
     // Decompose the preliminary ConstructorName into the type name and
     // the actual constructor name.
@@ skipping 384 matching lines @@
   void addCompileTimeError(Message message, int charOffset) {
     Code code = message.code;
     switch (code.analyzerCode) {
       case "EXPECTED_TYPE_NAME":
         errorReporter?.reportErrorForOffset(
             ParserErrorCode.EXPECTED_TYPE_NAME, charOffset, 1);
         return;
       default:
       // fall through
     }
-    library.deprecated_addCompileTimeError(charOffset, message.message,
-        fileUri: uri);
+    library.addCompileTimeError(message, charOffset, uri);
   }
 }
 
 /// Data structure placed on the stack to represent a class body.
 ///
 /// This is needed because analyzer has no separate AST representation of a
 /// class body; it simply stores all of the relevant data in the
 /// [ClassDeclaration] object.
 class _ClassBody {
   final Token beginToken;
@@ skipping 83 matching lines @@
         externalKeyword = token;
       } else if (identical('final', s)) {
         finalConstOrVarKeyword = token;
       } else if (identical('static', s)) {
         staticKeyword = token;
       } else if (identical('var', s)) {
         finalConstOrVarKeyword = token;
       } else if (identical('covariant', s)) {
         covariantKeyword = token;
       } else {
-        deprecated_internalProblem('Unhandled modifier: $s');
+        unhandled("$s", "modifier", token.charOffset, null);
       }
     }
   }
 }