Remove deprecated_internalProblem.

pkg/front_end/lib/src/fasta/kernel/body_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.body_builder;
 
-import '../fasta_codes.dart' show Message;
+import 'package:kernel/ast.dart'
+    hide InvalidExpression, InvalidInitializer, InvalidStatement;
+
+import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
+
+import 'package:kernel/clone.dart' show CloneVisitor;
+
+import 'package:kernel/core_types.dart' show CoreTypes;
+
+import 'package:kernel/transformations/flags.dart' show TransformerFlag;
+
+import '../../scanner/token.dart' show BeginToken, Token;
+
+import '../deprecated_problems.dart'
+    show deprecated_InputError, deprecated_formatUnexpected;
 
 import '../fasta_codes.dart' as fasta;
 
-import '../parser/parser.dart'
-    show Assert, FormalParameterType, MemberKind, optional;
+import '../fasta_codes.dart' show Message;
+
+import '../messages.dart' as messages show getLocationFromUri;
+
+import '../modifier.dart' show Modifier, constMask, finalMask;
 
 import '../parser/identifier_context.dart' show IdentifierContext;
 
 import '../parser/native_support.dart' show skipNativeClause;
 
-import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart';
+import '../parser/parser.dart'
+    show Assert, FormalParameterType, MemberKind, optional;
 
-import 'package:front_end/src/fasta/kernel/utils.dart' show offsetForToken;
-
-import 'package:front_end/src/fasta/type_inference/type_inferrer.dart'
-    show TypeInferrer;
-
-import 'package:front_end/src/fasta/type_inference/type_promotion.dart'
-    show TypePromoter;
-
-import 'package:kernel/ast.dart'
-    hide InvalidExpression, InvalidInitializer, InvalidStatement;
-
-import 'package:kernel/clone.dart' show CloneVisitor;
-
-import 'package:kernel/transformations/flags.dart' show TransformerFlag;
-
-import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
-
-import 'package:kernel/core_types.dart' show CoreTypes;
-
-import 'frontend_accessors.dart' show buildIsNull, makeBinary;
-
-import '../messages.dart' as messages show getLocationFromUri;
-
-import '../../scanner/token.dart' show BeginToken, Token;
-
-import '../scanner/token.dart' show isBinaryOperator, isMinusOperator;
-
-import '../deprecated_problems.dart'
-    show
-        deprecated_InputError,
-        deprecated_formatUnexpected,
-        deprecated_internalProblem;
-
-import '../source/scope_listener.dart'
-    show JumpTargetKind, NullValue, ScopeListener;
-
-import '../scope.dart' show ProblemBuilder;
-
-import 'fasta_accessors.dart';
+import '../problems.dart'
+    show internalProblem, unexpected, unhandled, unsupported;
 
 import '../quote.dart'
     show
         Quote,
         analyzeQuote,
         unescape,
         unescapeFirstStringPart,
         unescapeLastStringPart,
         unescapeString;
 
-import '../modifier.dart' show Modifier, constMask, finalMask;
+import '../scanner/token.dart' show isBinaryOperator, isMinusOperator;
+
+import '../scope.dart' show ProblemBuilder;
+
+import '../source/scope_listener.dart'
+    show JumpTargetKind, NullValue, ScopeListener;
+
+import '../type_inference/type_inferrer.dart' show TypeInferrer;
+
+import '../type_inference/type_promotion.dart' show TypePromoter;
+
+import 'frontend_accessors.dart' show buildIsNull, makeBinary;
 
 import 'redirecting_factory_body.dart'
     show
         RedirectingFactoryBody,
         getRedirectingFactoryBody,
         getRedirectionTarget;
 
+import 'utils.dart' show offsetForToken;
+
+import '../names.dart';
+
+import 'fasta_accessors.dart';
+
 import 'kernel_builder.dart';
 
-import '../names.dart';
+import 'kernel_shadow_ast.dart';
 
 class BodyBuilder extends ScopeListener<JumpTarget> implements BuilderHelper {
   @override
   final KernelLibraryBuilder library;
 
   final ModifierBuilder member;
 
   final KernelClassBuilder classBuilder;
 
   final ClassHierarchy hierarchy;
@@ skipping 133 matching lines @@
     if (node is FastaAccessor) {
       return node.buildSimpleRead();
     } else if (node is Expression) {
       return node;
     } else if (node is PrefixBuilder) {
       return deprecated_buildCompileTimeError(
           "A library can't be used as an expression.");
     } else if (node is ProblemBuilder) {
       return buildProblemExpression(node, -1);
     } else {
-      return deprecated_internalProblem("Unhandled: ${node.runtimeType}");
+      return unhandled("${node.runtimeType}", "toValue", -1, uri);
     }
   }
 
   Expression toEffect(Object node) {
     if (node is FastaAccessor) return node.buildForEffect();
     return toValue(node);
   }
 
   List<Expression> popListForValue(int n) {
     List<Expression> list =
@@ skipping 190 matching lines @@
       if (classBuilder != null) {
         field = classBuilder[name];
       } else {
         field = library[name];
       }
       fields.add(field);
       if (initializer != null) {
         if (field.next != null) {
           // TODO(ahe): This can happen, for example, if a final field is
           // combined with a setter.
-          deprecated_internalProblem(
-              "Unhandled: '${field.name}' has more than one declaration.");
+          unhandled("field with more than one declaration", field.name,
+              field.charOffset, field.fileUri);
         }
         field.initializer = initializer;
         _typeInferrer.inferFieldInitializer(
             field.hasImplicitType ? null : field.builtType, initializer);
       }
     }
     pop(); // Type.
     pop(); // Modifiers.
     List annotations = pop();
     if (annotations != null) {
@@ skipping 158 matching lines @@
         _typeInferrer.inferParameterInitializer(
             initializer, realParameter.type);
         realParameter.initializer = initializer..parent = realParameter;
       }
     }
     if (builder is KernelConstructorBuilder) {
       finishConstructor(builder, asyncModifier);
     } else if (builder is KernelProcedureBuilder) {
       builder.asyncModifier = asyncModifier;
     } else {
-      deprecated_internalProblem("Unhandled: ${builder.runtimeType}");
+      unhandled("${builder.runtimeType}", "finishFunction", builder.charOffset,
+          builder.fileUri);
     }
   }
 
   @override
   List<Expression> finishMetadata() {
     List<Expression> expressions = pop();
     _typeInferrer.inferMetadata(expressions);
     return expressions;
   }
 
@@ skipping 512 matching lines @@
         deprecated_addCompileTimeError(
             offsetForToken(token),
             "'$name' can't be used in a constant expression because it's "
             "marked as 'deferred' which means it isn't available until "
             "loaded.\n"
             "You might try moving the constant to the deferred library, "
             "or removing 'deferred' from the import.");
       }
       return builder;
     } else {
-      if (builder.hasProblem && builder is! deprecated_AccessErrorBuilder)
-        return builder;
+      if (builder.hasProblem && builder is! AccessErrorBuilder) return builder;
       Builder setter;
       if (builder.isSetter) {
         setter = builder;
       } else if (builder.isGetter) {
         setter = scope.lookupSetter(name, offsetForToken(token), uri);
       } else if (builder.isField && !builder.isFinal) {
         setter = builder;
       }
       StaticAccessor accessor =
           new StaticAccessor.fromBuilder(this, builder, token, setter);
@@ skipping 320 matching lines @@
       variables.add(variableOrExpression);
     } else if (variableOrExpression is List) {
       // TODO(sigmund): remove this assignment (see issue #28651)
       Iterable vars = variableOrExpression;
       variables.addAll(vars);
     } else if (variableOrExpression == null) {
       // Do nothing.
     } else if (variableOrExpression is Expression) {
       begin = new KernelExpressionStatement(variableOrExpression);
     } else {
-      return deprecated_internalProblem(
-          "Unhandled: ${variableOrExpression.runtimeType}");
+      return unhandled("${variableOrExpression.runtimeType}", "endForStatement",
+          forKeyword.charOffset, uri);
     }
     exitLocalScope();
     JumpTarget continueTarget = exitContinueTarget();
     JumpTarget breakTarget = exitBreakTarget();
     if (continueTarget.hasUsers) {
       body = new KernelLabeledStatement(body);
       continueTarget.resolveContinues(body);
     }
     Statement result =
         new KernelForStatement(variables, condition, updates, body);
@@ skipping 92 matching lines @@
     Expression key = popForValue();
     push(new MapEntry(key, value));
   }
 
   String symbolPartToString(name) {
     if (name is Identifier) {
       return name.name;
     } else if (name is Operator) {
       return name.name;
     } else {
-      return deprecated_internalProblem("Unhandled: ${name.runtimeType}");
+      return unhandled("${name.runtimeType}", "symbolPartToString", -1, uri);
     }
   }
 
   @override
   void endLiteralSymbol(Token hashToken, int identifierCount) {
     debugEvent("LiteralSymbol");
     String value;
     if (identifierCount == 1) {
       value = symbolPartToString(pop());
     } else {
@@ skipping 36 matching lines @@
   }
 
   @override
   void handleType(Token beginToken, Token endToken) {
     // TODO(ahe): The scope is wrong for return types of generic functions.
     debugEvent("Type");
     List<DartType> arguments = pop();
     dynamic name = pop();
     if (name is List) {
       if (name.length != 2) {
-        deprecated_internalProblem("Unexpected: $name.length");
+        unexpected("${name.length}", "2", beginToken.charOffset, uri);
       }
       var prefix = name[0];
       if (prefix is Identifier) {
         prefix = prefix.name;
       }
       var suffix = name[1];
       if (suffix is Identifier) {
         suffix = suffix.name;
       }
       Builder builder;
@@ skipping 21 matching lines @@
       warningNotError(fasta.templateNotAType.withArguments(beginToken.lexeme),
           beginToken.charOffset);
       push(const InvalidType());
     } else if (name is TypeBuilder) {
       push(name.build(library));
     } else if (name is Builder) {
       push(kernelTypeFromBuilder(name, arguments, beginToken.charOffset));
     } else if (name is String) {
       push(kernelTypeFromString(name, arguments, beginToken.charOffset));
     } else {
-      deprecated_internalProblem("Unhandled: '${name.runtimeType}'.");
+      unhandled(
+          "${name.runtimeType}", "handleType", beginToken.charOffset, uri);
     }
     // TODO(ahe): Unused code fasta.messageNonInstanceTypeVariableUse.
   }
 
   @override
   void beginFunctionType(Token beginToken) {
     debugEvent("beginFunctionType");
     enterFunctionTypeScope();
   }
 
@@ skipping 115 matching lines @@
     bool isConst = (modifiers & constMask) != 0;
     bool isFinal = (modifiers & finalMask) != 0;
     ignore(Unhandled.Metadata);
     VariableDeclaration variable;
     if (!inCatchClause &&
         functionNestingLevel == 0 &&
         memberKind != MemberKind.GeneralizedFunctionType) {
       ProcedureBuilder member = this.member;
       KernelFormalParameterBuilder formal = member.getFormal(name.name);
       if (formal == null) {
-        deprecated_internalProblem(
-            "Internal error: formal missing for '${name.name}'");
+        internalProblem(
+            fasta.templateInternalProblemNotFoundIn
+                .withArguments(name.name, "formals"),
+            member.charOffset,
+            member.fileUri);
       } else {
         variable = formal.build(library);
         variable.initializer = name.initializer;
       }
     } else {
       variable = new KernelVariableDeclaration(name?.name, functionNestingLevel,
           type: type,
           initializer: name?.initializer,
           isFinal: isFinal,
           isConst: isConst);
@@ skipping 189 matching lines @@
             // This *could* be a constant expression, we can't know without
             // evaluating [receiver].
             isConstantExpression: true));
       }
     }
   }
 
   Name incrementOperator(Token token) {
     if (optional("++", token)) return plusName;
     if (optional("--", token)) return minusName;
-    return deprecated_internalProblem(
-        "Unknown increment operator: ${token.lexeme}");
+    return unhandled(token.lexeme, "incrementOperator", token.charOffset, uri);
   }
 
   @override
   void handleUnaryPrefixAssignmentExpression(Token token) {
     debugEvent("UnaryPrefixAssignmentExpression");
     var accessor = pop();
     if (accessor is FastaAccessor) {
       push(accessor.buildPrefixIncrement(incrementOperator(token),
           offset: token.charOffset));
     } else {
@@ skipping 1339 matching lines @@
 
 abstract class ContextAccessor extends FastaAccessor {
   final BuilderHelper helper;
 
   final FastaAccessor accessor;
 
   final Token token;
 
   ContextAccessor(this.helper, this.token, this.accessor);
 
-  String get plainNameForRead =>
-      deprecated_internalProblem("Unsupported operation.");
+  String get plainNameForRead {
+    return unsupported("plainNameForRead", token.charOffset, helper.uri);
+  }
 
   Expression doInvocation(int charOffset, Arguments arguments) {
-    return deprecated_internalProblem(
-        "Unhandled: ${runtimeType}", uri, charOffset);
+    return unhandled("${runtimeType}", "doInvocation", charOffset, uri);
   }
 
   Expression buildSimpleRead();
 
   Expression buildForEffect();
 
   Expression buildAssignment(Expression value, {bool voidContext: false}) {
     return makeInvalidWrite(value);
   }
 
@@ skipping 18 matching lines @@
     return makeInvalidWrite(null);
   }
 
   Expression buildPostfixIncrement(Name binaryOperator,
       {int offset: TreeNode.noOffset,
       bool voidContext: false,
       Procedure interfaceTarget}) {
     return makeInvalidWrite(null);
   }
 
-  makeInvalidRead() => deprecated_internalProblem("not supported");
+  makeInvalidRead() {
+    return unsupported("makeInvalidRead", token.charOffset, helper.uri);
+  }
 
   Expression makeInvalidWrite(Expression value) {
     return helper.deprecated_buildCompileTimeError(
         "Can't be used as left-hand side of assignment.",
         offsetForToken(token));
   }
 }
 
 class DelayedAssignment extends ContextAccessor {
   final Expression value;
@@ skipping 50 matching lines @@
     } else if (identical("^=", assignmentOperator)) {
       return accessor.buildCompoundAssignment(caretName, value,
           offset: offsetForToken(token), voidContext: voidContext);
     } else if (identical("|=", assignmentOperator)) {
       return accessor.buildCompoundAssignment(barName, value,
           offset: offsetForToken(token), voidContext: voidContext);
     } else if (identical("~/=", assignmentOperator)) {
       return accessor.buildCompoundAssignment(mustacheName, value,
           offset: offsetForToken(token), voidContext: voidContext);
     } else {
-      return deprecated_internalProblem("Unhandled: $assignmentOperator");
+      return unhandled(
+          assignmentOperator, "handleAssignment", token.charOffset, helper.uri);
     }
   }
 
   @override
   Initializer buildFieldInitializer(Map<String, int> initializedFields) {
     if (!identical("=", assignmentOperator) ||
         !accessor.isThisPropertyAccessor) {
       return accessor.buildFieldInitializer(initializedFields);
     }
     return helper.buildFieldInitializer(
@@ skipping 96 matching lines @@
 
   LabelTarget(MemberBuilder member, this.functionNestingLevel, int charOffset)
       : breakTarget = new JumpTarget(
             JumpTargetKind.Break, functionNestingLevel, member, charOffset),
         continueTarget = new JumpTarget(
             JumpTargetKind.Continue, functionNestingLevel, member, charOffset),
         super(member, charOffset, member.fileUri);
 
   bool get hasUsers => breakTarget.hasUsers || continueTarget.hasUsers;
 
-  List<Statement> get users =>
-      deprecated_internalProblem("Unsupported operation.");
+  List<Statement> get users => unsupported("users", charOffset, fileUri);
 
-  JumpTargetKind get kind =>
-      deprecated_internalProblem("Unsupported operation.");
+  JumpTargetKind get kind => unsupported("kind", charOffset, fileUri);
 
   bool get isBreakTarget => true;
 
   bool get isContinueTarget => true;
 
   bool get isGotoTarget => false;
 
   void addBreak(BreakStatement statement) {
     breakTarget.addBreak(statement);
   }
 
   void addContinue(BreakStatement statement) {
     continueTarget.addContinue(statement);
   }
 
   void addGoto(ContinueSwitchStatement statement) {
-    deprecated_internalProblem("Unsupported operation.");
+    unsupported("addGoto", charOffset, fileUri);
   }
 
   void resolveBreaks(LabeledStatement target) {
     breakTarget.resolveBreaks(target);
   }
 
   void resolveContinues(LabeledStatement target) {
     continueTarget.resolveContinues(target);
   }
 
   void resolveGotos(SwitchCase target) {
-    deprecated_internalProblem("Unsupported operation.");
+    unsupported("resolveGotos", charOffset, fileUri);
   }
 
   @override
   String get fullNameForErrors => "<label-target>";
 }
 
 class OptionalFormals {
   final FormalParameterType kind;
 
   final List<VariableDeclaration> formals;
@@ skipping 105 matching lines @@
 String getNodeName(Object node) {
   if (node is Identifier) {
     return node.name;
   } else if (node is Builder) {
     return node.fullNameForErrors;
   } else if (node is ThisAccessor) {
     return node.isSuper ? "super" : "this";
   } else if (node is FastaAccessor) {
     return node.plainNameForRead;
   } else {
-    return deprecated_internalProblem("Unhandled: ${node.runtimeType}");
+    return unhandled("${node.runtimeType}", "getNodeName", -1, null);
   }
 }
 
 AsyncMarker asyncMarkerFromTokens(Token asyncToken, Token starToken) {
   if (asyncToken == null || identical(asyncToken.stringValue, "sync")) {
     if (starToken == null) {
       return AsyncMarker.Sync;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.SyncStar;
     }
   } else if (identical(asyncToken.stringValue, "async")) {
     if (starToken == null) {
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
-    return deprecated_internalProblem("Unknown async modifier: $asyncToken");
+    return unhandled(asyncToken.lexeme, "asyncMarkerFromTokens",
+        asyncToken.charOffset, null);
   }
 }