Deprecate all diagnostics methods that use strings.

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/errors.dart' show internalError;
+import 'package:front_end/src/fasta/deprecated_problems.dart'
+    show deprecated_internalProblem;
 import 'package:front_end/src/fasta/fasta_codes.dart'
     show
         FastaCode,
         FastaMessage,
         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;
@@ skipping 130 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 {
-          internalError(
+          deprecated_internalProblem(
               "Unexpected part in string interpolation: ${part.runtimeType}");
         }
       }
       elements.add(ast.interpolationString(
           last, unescapeLastStringPart(last.lexeme, quote)));
       push(ast.stringInterpolation(elements));
     }
   }
 
   void handleScript(Token token) {
@@ skipping 119 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 {
-      internalError("Internal error: expected procedure, but got: $member");
+      deprecated_internalProblem(
+          "Internal error: expected procedure, but got: $member");
     }
   }
 
   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 {
-      internalError(
+      deprecated_internalProblem(
           "Unhandled property access: ${identifierOrInvoke.runtimeType}");
     }
   }
 
   void handleLiteralInt(Token token) {
     debugEvent("LiteralInt");
     push(ast.integerLiteral(token, int.parse(token.lexeme)));
   }
 
   void handleExpressionFunctionBody(Token arrowToken, Token endToken) {
@@ skipping 129 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 {
-      internalError("unhandled identifier: ${node.runtimeType}");
+      deprecated_internalProblem("unhandled identifier: ${node.runtimeType}");
     }
     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 {
-          internalError(
+          deprecated_internalProblem(
               'Unrecognized compilation unit member: ${node.runtimeType}');
         }
       }
     }
 
     push(ast.compilationUnit(
         beginToken, scriptTag, directives, declarations, endToken));
   }
 
   void endImport(Token importKeyword, Token deferredKeyword, Token asKeyword,
@@ skipping 141 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 {
-      internalError('Unexpected kind of supertype ${supertype.runtimeType}');
+      deprecated_internalProblem(
+          'Unexpected kind of supertype ${supertype.runtimeType}');
     }
     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 {
-      internalError('Unexpected body object: ${bodyObject.runtimeType}');
+      deprecated_internalProblem(
+          'Unexpected body object: ${bodyObject.runtimeType}');
     }
 
     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 addCompileTimeErrorFromMessage(FastaMessage message) {
     FastaCode code = message.code;
     switch (code.analyzerCode) {
       case "EXPECTED_TYPE_NAME":
         errorReporter?.reportErrorForOffset(
             ParserErrorCode.EXPECTED_TYPE_NAME, message.charOffset, 1);
         return;
       default:
       // fall through
     }
-    library.addCompileTimeError(message.charOffset, message.message,
+    library.deprecated_addCompileTimeError(message.charOffset, message.message,
         fileUri: message.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 {
@@ skipping 84 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 {
-        internalError('Unhandled modifier: $s');
+        deprecated_internalProblem('Unhandled modifier: $s');
       }
     }
   }
 }