Deprecate all diagnostics methods that use strings.

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
         FastaMessage,
         codeConstFieldWithoutInitializer,
@@ skipping 30 matching lines @@
 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 '../errors.dart' show InputError, formatUnexpected, internalError;
+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 '../quote.dart'
     show
@@ skipping 156 matching lines @@
     return value == null ? null : popForValue();
   }
 
   @override
   Expression toValue(Object node) {
     if (node is FastaAccessor) {
       return node.buildSimpleRead();
     } else if (node is Expression) {
       return node;
     } else if (node is PrefixBuilder) {
-      return buildCompileTimeError("A library can't be used as an expression.");
+      return deprecated_buildCompileTimeError(
+          "A library can't be used as an expression.");
     } else if (node is ProblemBuilder) {
       return buildProblemExpression(node, -1);
     } else {
-      return internalError("Unhandled: ${node.runtimeType}");
+      return deprecated_internalProblem("Unhandled: ${node.runtimeType}");
     }
   }
 
   Expression toEffect(Object node) {
     if (node is FastaAccessor) return node.buildForEffect();
     return toValue(node);
   }
 
   List<Expression> popListForValue(int n) {
     List<Expression> list =
@@ skipping 55 matching lines @@
     push(switchScope ?? NullValue.SwitchScope);
     switchScope = scope;
   }
 
   void exitSwitchScope() {
     Scope outerSwitchScope = pop();
     if (switchScope.unclaimedForwardDeclarations != null) {
       switchScope.unclaimedForwardDeclarations
           .forEach((String name, Builder builder) {
         if (outerSwitchScope == null) {
-          addCompileTimeError(-1, "Label not found: '$name'.");
+          deprecated_addCompileTimeError(-1, "Label not found: '$name'.");
         } else {
           outerSwitchScope.forwardDeclareLabel(name, builder);
         }
       });
     }
     switchScope = outerSwitchScope;
   }
 
   void declareVariable(VariableDeclaration variable) {
     // ignore: UNUSED_LOCAL_VARIABLE
     Statement discardedStatement;
     String name = variable.name;
     int offset = variable.fileOffset;
     if (scope.local[name] != null) {
       // This reports an error for duplicated declarations in the same scope:
       // `{ var x; var x; }`
       discardedStatement = pop(); // TODO(ahe): Issue 29717.
-      push(buildCompileTimeErrorStatement(
+      push(deprecated_buildCompileTimeErrorStatement(
           "'$name' already declared in this scope.", offset));
       return;
     }
-    InputError error = scope.declare(
+    deprecated_InputError error = scope.declare(
         variable.name,
         new KernelVariableBuilder(
             variable, member ?? classBuilder ?? library, uri),
         variable.fileOffset,
         uri);
     if (error != null) {
       // This case is different from the above error. In this case, the problem
       // is using `x` before it's declared: `{ var x; { print(x); var x;
       // }}`. In this case, we want two errors, the `x` in `print(x)` and the
       // second (or innermost declaration) of `x`.
       discardedStatement = pop(); // TODO(ahe): Issue 29717.
 
       // Reports the error on the last declaration of `x`.
-      push(buildCompileTimeErrorStatement(
+      push(deprecated_buildCompileTimeErrorStatement(
           "Can't declare '$name' because it was already used in this scope.",
           offset));
 
       // Reports the error on `print(x)`.
-      library.addCompileTimeError(error.charOffset, error.error,
+      library.deprecated_addCompileTimeError(error.charOffset, error.error,
           fileUri: error.uri);
     }
   }
 
   @override
   JumpTarget createJumpTarget(JumpTargetKind kind, int charOffset) {
     return new JumpTarget(kind, functionNestingLevel, member, charOffset);
   }
 
   @override
@@ skipping 26 matching lines @@
         FastaAccessor accessor = expression;
         expression = accessor.buildPropertyAccess(
             new IncompletePropertyAccessor(
                 this, period.next, new Name(name, library.library)),
             period.next.offset,
             false);
       }
 
       bool savedConstantExpressionRequired = pop();
       if (expression is! StaticAccessor) {
-        push(wrapInCompileTimeError(
+        push(deprecated_wrapInCompileTimeError(
             toValue(expression),
             "This can't be used as metadata; metadata should be a reference to "
             "a compile-time constant variable, or "
             "a call to a constant constructor."));
       } else {
         push(toValue(expression));
       }
       constantExpressionRequired = savedConstantExpressionRequired;
     }
   }
@@ skipping 26 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.
-          internalError(
+          deprecated_internalProblem(
               "Unhandled: '${field.name}' has more than one declaration.");
         }
         field.initializer = initializer;
         _typeInferrer.inferFieldInitializer(
             field.hasImplicitType ? null : field.builtType, initializer);
       }
     }
     pop(); // Type.
     pop(); // Modifiers.
     List annotations = pop();
@@ skipping 31 matching lines @@
       push(block);
     }
   }
 
   void prepareInitializers() {
     ProcedureBuilder member = this.member;
     scope = member.computeFormalParameterInitializerScope(scope);
     if (member is KernelConstructorBuilder) {
       if (member.isConst &&
           (classBuilder.cls.superclass?.isMixinApplication ?? false)) {
-        addCompileTimeError(member.charOffset,
+        deprecated_addCompileTimeError(member.charOffset,
             "Can't extend a mixin application and be 'const'.");
       }
       if (member.formals != null) {
         for (KernelFormalParameterBuilder formal in member.formals) {
           if (formal.hasThis) {
             Initializer initializer;
             if (member.isExternal) {
               initializer = buildInvalidInitializer(
-                  buildCompileTimeError(
+                  deprecated_buildCompileTimeError(
                       "An external constructor can't initialize fields.",
                       formal.charOffset),
                   formal.charOffset);
             } else {
               initializer = buildFieldInitializer(formal.name,
                   formal.charOffset, new VariableGet(formal.declaration));
             }
             member.addInitializer(initializer);
           }
         }
@@ skipping 42 matching lines @@
     if (node is Initializer) {
       initializer = node;
     } else if (node is FastaAccessor) {
       initializer = node.buildFieldInitializer(initializedFields);
     } else if (node is ConstructorInvocation) {
       initializer =
           buildSuperInitializer(node.target, node.arguments, token.charOffset);
     } else {
       Expression value = toValue(node);
       if (node is! Throw) {
-        value = wrapInCompileTimeError(value, "Expected an initializer.");
+        value = deprecated_wrapInCompileTimeError(
+            value, "Expected an initializer.");
       }
       initializer = buildInvalidInitializer(node, token.charOffset);
     }
     _typeInferrer.inferInitializer(initializer);
     if (member is KernelConstructorBuilder && !member.isExternal) {
       member.addInitializer(initializer);
     } else {
-      addCompileTimeError(
+      deprecated_addCompileTimeError(
           token.charOffset, "Can't have initializers: ${member.name}");
     }
   }
 
   DartType _computeReturnTypeContext(MemberBuilder member) {
     if (member is KernelProcedureBuilder) {
       return member.target.function.returnType;
     } else {
       assert(member is KernelConstructorBuilder);
       return null;
@@ skipping 26 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 {
-      internalError("Unhandled: ${builder.runtimeType}");
+      deprecated_internalProblem("Unhandled: ${builder.runtimeType}");
     }
   }
 
   @override
   List<Expression> finishMetadata() {
     List<Expression> expressions = pop();
     _typeInferrer.inferMetadata(expressions);
     return expressions;
   }
 
   void finishConstructor(
       KernelConstructorBuilder builder, AsyncMarker asyncModifier) {
     /// Quotes below are from [Dart Programming Language Specification, 4th
     /// Edition](
     /// https://ecma-international.org/publications/files/ECMA-ST/ECMA-408.pdf).
     assert(builder == member);
     Constructor constructor = builder.constructor;
     if (asyncModifier != AsyncMarker.Sync) {
       // TODO(ahe): Change this to a null check.
       int offset = builder.body?.fileOffset ?? builder.charOffset;
       constructor.initializers.add(buildInvalidInitializer(
-          buildCompileTimeError(
+          deprecated_buildCompileTimeError(
               "A constructor can't be '${asyncModifier}'.", offset),
           offset));
     }
     if (needsImplicitSuperInitializer) {
       /// >If no superinitializer is provided, an implicit superinitializer
       /// >of the form super() is added at the end of k’s initializer list,
       /// >unless the enclosing class is class Object.
       Constructor superTarget = lookupConstructor(emptyName, isSuper: true);
       Initializer initializer;
       Arguments arguments = new Arguments.empty();
       if (superTarget == null ||
           !checkArguments(
               superTarget.function, arguments, const <TypeParameter>[])) {
         String superclass = classBuilder.supertype.fullNameForErrors;
         String message = superTarget == null
             ? "'$superclass' doesn't have an unnamed constructor."
             : "The unnamed constructor in '$superclass' requires arguments.";
         initializer = buildInvalidInitializer(
-            buildCompileTimeError(message, builder.charOffset),
+            deprecated_buildCompileTimeError(message, builder.charOffset),
             builder.charOffset);
       } else {
         initializer =
             buildSuperInitializer(superTarget, arguments, builder.charOffset);
       }
       constructor.initializers.add(initializer);
     }
     setParents(constructor.initializers, constructor);
     if (constructor.function.body == null) {
       /// >If a generative constructor c is not a redirecting constructor
@@ skipping 18 matching lines @@
     for (int i = 0; i < arguments.length; i++) {
       var node = arguments[i];
       if (node is NamedExpression) {
         firstNamedArgumentIndex =
             i < firstNamedArgumentIndex ? i : firstNamedArgumentIndex;
       } else {
         arguments[i] = toValue(node);
         if (i > firstNamedArgumentIndex) {
           arguments[i] = new NamedExpression(
               "#$i",
-              buildCompileTimeError(
+              deprecated_buildCompileTimeError(
                   "Expected named argument.", arguments[i].fileOffset))
             ..fileOffset = beginToken.charOffset;
         }
       }
     }
     if (firstNamedArgumentIndex < arguments.length) {
       List<Expression> positional = new List<Expression>.from(
           arguments.getRange(0, firstNamedArgumentIndex));
       List<NamedExpression> named = new List<NamedExpression>.from(
           arguments.getRange(firstNamedArgumentIndex, arguments.length));
       if (named.length == 2) {
         if (named[0].name == named[1].name) {
           named = <NamedExpression>[
             new NamedExpression(
                 named[1].name,
-                buildCompileTimeError(
+                deprecated_buildCompileTimeError(
                     "Duplicated named argument '${named[1].name}'.",
                     named[1].fileOffset))
           ];
         }
       } else if (named.length > 2) {
         Map<String, NamedExpression> seenNames = <String, NamedExpression>{};
         bool hasProblem = false;
         for (NamedExpression expression in named) {
           if (seenNames.containsKey(expression.name)) {
             hasProblem = true;
-            seenNames[expression.name].value = buildCompileTimeError(
+            seenNames[expression.name].value = deprecated_buildCompileTimeError(
                 "Duplicated named argument '${expression.name}'.",
                 expression.fileOffset);
           } else {
             seenNames[expression.name] = expression;
           }
         }
         if (hasProblem) {
           named = new List<NamedExpression>.from(seenNames.values);
         }
       }
@@ skipping 112 matching lines @@
 
   Expression buildBinaryOperator(
       Expression a, Token token, Expression b, bool isSuper) {
     bool negate = false;
     String operator = token.stringValue;
     if (identical("!=", operator)) {
       operator = "==";
       negate = true;
     }
     if (!isBinaryOperator(operator) && !isMinusOperator(operator)) {
-      return buildCompileTimeError(
+      return deprecated_buildCompileTimeError(
           "Not an operator: '$operator'.", token.charOffset);
     } else {
       Expression result =
           makeBinary(a, new Name(operator), null, b, offset: token.charOffset);
       if (isSuper) {
         result = toSuperMethodInvocation(result);
       }
       return negate ? new KernelNot(result) : result;
     }
   }
@@ skipping 32 matching lines @@
   }
 
   @override
   Expression toSuperMethodInvocation(MethodInvocation node) {
     Member target = lookupSuperMember(node.name);
     if (target == null || (target is Procedure && !target.isAccessor)) {
       if (target == null) {
         warnUnresolvedSuperMethod(node.name, node.fileOffset);
       } else if (!areArgumentsCompatible(target.function, node.arguments)) {
         target = null;
-        warning(
+        deprecated_warning(
             "Super class doesn't have a method named '${node.name.name}' "
             "with matching arguments.",
             node.fileOffset);
       }
       Expression result;
       if (target != null) {
         result = new KernelDirectMethodInvocation(
             new KernelThisExpression()..fileOffset = node.fileOffset,
             target,
             node.arguments);
@@ skipping 35 matching lines @@
       message = "Getter not found: '$errorName'.";
     } else if (isSetter) {
       message = "Setter not found: '$errorName'.";
     } else {
       message = "Method not found: '$errorName'.";
     }
     if (constantExpressionRequired) {
       // TODO(ahe): Use error below instead of building a compile-time error,
       // should be:
       //    return library.loader.throwCompileConstantError(error, charOffset);
-      return buildCompileTimeError(message, charOffset);
+      return deprecated_buildCompileTimeError(message, charOffset);
     } else {
       Expression error = library.loader.instantiateNoSuchMethodError(
           receiver, name, arguments, charOffset,
           isMethod: !isGetter && !isSetter,
           isGetter: isGetter,
           isSetter: isSetter,
           isStatic: isStatic,
           isTopLevel: !isStatic && !isSuper);
-      warning(message, charOffset);
+      deprecated_warning(message, charOffset);
       return new KernelSyntheticExpression(new Throw(error));
     }
   }
 
   @override
   void warnUnresolvedSuperGet(Name name, int charOffset) {
-    warning("Super class has no getter named '${name.name}'.", charOffset);
+    deprecated_warning(
+        "Super class has no getter named '${name.name}'.", charOffset);
   }
 
   @override
   void warnUnresolvedSuperSet(Name name, int charOffset) {
-    warning("Super class has no setter named '${name.name}'.", charOffset);
+    deprecated_warning(
+        "Super class has no setter named '${name.name}'.", charOffset);
   }
 
   @override
   void warnUnresolvedSuperMethod(Name name, int charOffset) {
-    warning("Super class has no method named '${name.name}'.", charOffset);
+    deprecated_warning(
+        "Super class has no method named '${name.name}'.", charOffset);
   }
 
   @override
   Member lookupSuperMember(Name name, {bool isSetter: false}) {
     Class superclass = classBuilder.cls.superclass;
     return superclass == null
         ? null
         : hierarchy.getDispatchTarget(superclass, name, setter: isSetter);
   }
 
@@ skipping 26 matching lines @@
       Scope scope = inInitializer ? enclosingScope : this.scope;
       push(scopeLookup(scope, name, token));
       return;
     } else if (context.inDeclaration) {
       if (context == IdentifierContext.topLevelVariableDeclaration ||
           context == IdentifierContext.fieldDeclaration) {
         constantExpressionRequired = member.isConst;
       }
     } else if (constantExpressionRequired &&
         !context.allowedInConstantExpression) {
-      addCompileTimeError(
+      deprecated_addCompileTimeError(
           token.charOffset, "Not a constant expression: $context");
     }
     push(new Identifier(token));
   }
 
   /// Look up [name] in [scope] using [token] as location information (both to
   /// report problems and as the file offset in the generated kernel code).
   /// [isQualified] should be true if [name] is a qualified access
   /// (which implies that it shouldn't be turned into a [ThisPropertyAccessor]
   /// if the name doesn't resolve in the scope).
   @override
   scopeLookup(Scope scope, String name, Token token,
       {bool isQualified: false, PrefixBuilder prefix}) {
     Builder builder = scope.lookup(name, offsetForToken(token), uri);
     if (builder != null && member.isField && builder.isInstanceMember) {
-      return new IncompleteError(this, token,
+      return new deprecated_IncompleteError(this, token,
           "Can't access 'this' in a field initializer to read '$name'.");
     }
     if (builder == null || (!isInstanceContext && builder.isInstanceMember)) {
       Name n = new Name(name, library.library);
       if (prefix != null &&
           prefix.deferred &&
           builder == null &&
           "loadLibrary" == name) {
         int offset = offsetForToken(token);
         const String message = "Deferred loading isn't implemented yet.";
         // We report the error twice, the first time silently and marking it as
         // unhandled. This ensures that the compile-time error is reported
         // eagerly by kernel-service, thus preventing any attempts from running
         // a program that uses deferred loading. Obviously, this is a temporary
         // solution until we can fully implement deferred loading.
-        addCompileTimeError(offset, message, wasHandled: false, silent: true);
-        return buildCompileTimeError(message, offset);
+        deprecated_addCompileTimeError(offset, message,
+            wasHandled: false, silent: true);
+        return deprecated_buildCompileTimeError(message, offset);
       } else if (!isQualified && isInstanceContext) {
         assert(builder == null);
         if (constantExpressionRequired || member.isField) {
           return new UnresolvedAccessor(this, n, token);
         }
         return new ThisPropertyAccessor(this, token, n, null, null);
       } else if (ignoreMainInGetMainClosure &&
           name == "main" &&
           member?.name == "_getMainClosure") {
         return new KernelNullLiteral()..fileOffset = offsetForToken(token);
       } else {
         return new UnresolvedAccessor(this, n, token);
       }
     } else if (builder.isTypeDeclaration) {
       if (constantExpressionRequired &&
           builder.isTypeVariable &&
           !member.isConstructor) {
-        addCompileTimeError(
+        deprecated_addCompileTimeError(
             offsetForToken(token), "Not a constant expression.");
       }
       return new TypeDeclarationAccessor(this, builder, name, token);
     } else if (builder.isLocal) {
       if (constantExpressionRequired &&
           !builder.isConst &&
           !member.isConstructor) {
-        addCompileTimeError(
+        deprecated_addCompileTimeError(
             offsetForToken(token), "Not a constant expression.");
       }
       // An initializing formal parameter might be final without its
       // VariableDeclaration being final. See
       // [ProcedureBuilder.computeFormalParameterInitializerScope]. If that
       // wasn't the case, we could always use VariableAccessor.
       if (builder.isFinal) {
         var fact =
             typePromoter.getFactForAccess(builder.target, functionNestingLevel);
         var scope = typePromoter.currentScope;
         return new ReadOnlyAccessor(
             this,
             new KernelVariableGet(builder.target, fact, scope)
               ..fileOffset = offsetForToken(token),
             name,
             token);
       } else {
         return new VariableAccessor(this, token, builder.target);
       }
     } else if (builder.isInstanceMember) {
       if (constantExpressionRequired &&
           !inInitializer &&
           // TODO(ahe): This is a hack because Fasta sets up the scope
           // "this.field" parameters according to old semantics. Under the new
           // semantics, such parameters introduces a new parameter with that
           // name that should be resolved here.
           !member.isConstructor) {
-        addCompileTimeError(
+        deprecated_addCompileTimeError(
             offsetForToken(token), "Not a constant expression.");
       }
       return new ThisPropertyAccessor(
           this, token, new Name(name, library.library), null, null);
     } else if (builder.isRegularMethod) {
       assert(builder.isStatic || builder.isTopLevel);
       return new StaticAccessor(this, token, builder.target, null);
     } else if (builder is PrefixBuilder) {
       if (constantExpressionRequired && builder.deferred) {
-        addCompileTimeError(
+        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! AccessErrorBuilder) return builder;
+      if (builder.hasProblem && builder is! deprecated_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);
       if (constantExpressionRequired) {
         Member readTarget = accessor.readTarget;
         if (!(readTarget is Field && readTarget.isConst ||
             // Static tear-offs are also compile time constants.
             readTarget is Procedure)) {
-          addCompileTimeError(
+          deprecated_addCompileTimeError(
               offsetForToken(token), "Not a constant expression.");
         }
       }
       return accessor;
     }
   }
 
   @override
   void handleQualified(Token period) {
     debugEvent("Qualified");
@@ skipping 101 matching lines @@
     debugEvent("ExpressionFunctionBody");
     endReturnStatement(true, arrowToken.next, endToken);
   }
 
   @override
   void endReturnStatement(
       bool hasExpression, Token beginToken, Token endToken) {
     debugEvent("ReturnStatement");
     Expression expression = hasExpression ? popForValue() : null;
     if (expression != null && inConstructor) {
-      push(buildCompileTimeErrorStatement(
+      push(deprecated_buildCompileTimeErrorStatement(
           "Can't return from a constructor.", beginToken.charOffset));
     } else {
       push(new KernelReturnStatement(expression)
         ..fileOffset = beginToken.charOffset);
     }
   }
 
   @override
   void beginThenStatement(Token token) {
     Expression condition = popForValue();
@@ skipping 28 matching lines @@
   void handleNoVariableInitializer(Token token) {
     debugEvent("NoVariableInitializer");
     bool isConst = (currentLocalVariableModifiers & constMask) != 0;
     bool isFinal = (currentLocalVariableModifiers & finalMask) != 0;
     Expression initializer;
     if (!optional("in", token)) {
       // A for-in loop-variable can't have an initializer. So let's remain
       // silent if the next token is `in`. Since a for-in loop can only have
       // one variable it must be followed by `in`.
       if (isConst) {
-        initializer = buildCompileTimeError(
+        initializer = deprecated_buildCompileTimeError(
             "A 'const' variable must be initialized.", token.charOffset);
       } else if (isFinal) {
-        initializer = buildCompileTimeError(
+        initializer = deprecated_buildCompileTimeError(
             "A 'final' variable must be initialized.", token.charOffset);
       }
     }
     pushNewLocalVariable(initializer);
   }
 
   void pushNewLocalVariable(Expression initializer, {Token equalsToken}) {
     Identifier identifier = pop();
     assert(currentLocalVariableModifiers != -1);
     bool isConst = (currentLocalVariableModifiers & constMask) != 0;
@@ skipping 71 matching lines @@
     exitLocalScope();
     push(block);
   }
 
   @override
   void handleAssignmentExpression(Token token) {
     debugEvent("AssignmentExpression");
     Expression value = popForValue();
     var accessor = pop();
     if (accessor is! FastaAccessor) {
-      push(buildCompileTimeError("Can't assign to this.", token.charOffset));
+      push(deprecated_buildCompileTimeError(
+          "Can't assign to this.", token.charOffset));
     } else {
       push(new DelayedAssignment(
           this, token, accessor, value, token.stringValue));
     }
   }
 
   @override
   void enterLoop(int charOffset) {
     if (peek() is LabelTarget) {
       LabelTarget target = peek();
@@ skipping 37 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 internalError("Unhandled: ${variableOrExpression.runtimeType}");
+      return deprecated_internalProblem(
+          "Unhandled: ${variableOrExpression.runtimeType}");
     }
     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 24 matching lines @@
   void handleLiteralList(
       int count, Token beginToken, Token constKeyword, Token endToken) {
     debugEvent("LiteralList");
     List<Expression> expressions = popListForValue(count);
     List<DartType> typeArguments = pop();
     DartType typeArgument;
     if (typeArguments != null) {
       typeArgument = typeArguments.first;
       if (typeArguments.length > 1) {
         typeArgument = null;
-        warningNotError(
+        deprecated_warningNotError(
             "Too many type arguments on List literal.", beginToken.charOffset);
       }
     }
     push(new KernelListLiteral(expressions,
         typeArgument: typeArgument, isConst: constKeyword != null)
       ..fileOffset = offsetForToken(constKeyword ?? beginToken));
   }
 
   @override
   void handleLiteralBool(Token token) {
@@ skipping 21 matching lines @@
       int count, Token beginToken, Token constKeyword, Token endToken) {
     debugEvent("LiteralMap");
     List<MapEntry> entries = popList(count) ?? <MapEntry>[];
     List<DartType> typeArguments = pop();
     DartType keyType;
     DartType valueType;
     if (typeArguments != null) {
       if (typeArguments.length != 2) {
         keyType = null;
         valueType = null;
-        warningNotError(
+        deprecated_warningNotError(
             "Map literal requires two type arguments.", beginToken.charOffset);
       } else {
         keyType = typeArguments[0];
         valueType = typeArguments[1];
       }
     }
     push(new KernelMapLiteral(entries,
         keyType: keyType, valueType: valueType, isConst: constKeyword != null)
       ..fileOffset = constKeyword?.charOffset ?? offsetForToken(beginToken));
   }
 
   @override
   void endLiteralMapEntry(Token colon, Token endToken) {
     debugEvent("LiteralMapEntry");
     Expression value = popForValue();
     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 internalError("Unhandled: ${name.runtimeType}");
+      return deprecated_internalProblem("Unhandled: ${name.runtimeType}");
     }
   }
 
   @override
   void endLiteralSymbol(Token hashToken, int identifierCount) {
     debugEvent("LiteralSymbol");
     String value;
     if (identifierCount == 1) {
       value = symbolPartToString(pop());
     } else {
       List parts = popList(identifierCount);
       value = symbolPartToString(parts.first);
       for (int i = 1; i < parts.length; i++) {
         value += ".${symbolPartToString(parts[i])}";
       }
     }
     push(
         new KernelSymbolLiteral(value)..fileOffset = offsetForToken(hashToken));
   }
 
   DartType kernelTypeFromString(
       String name, List<DartType> arguments, int charOffset) {
     Builder builder = scope.lookup(name, charOffset, uri);
     if (builder == null) {
-      warning("Type not found: '$name'.", charOffset);
+      deprecated_warning("Type not found: '$name'.", charOffset);
       return const InvalidType();
     } else {
       return kernelTypeFromBuilder(builder, arguments, charOffset);
     }
   }
 
   DartType kernelTypeFromBuilder(
       Builder builder, List<DartType> arguments, int charOffset) {
     if (constantExpressionRequired && builder is TypeVariableBuilder) {
-      addCompileTimeError(charOffset, "Not a constant expression.");
+      deprecated_addCompileTimeError(charOffset, "Not a constant expression.");
     }
     if (builder.hasProblem) {
       ProblemBuilder problem = builder;
-      addCompileTimeError(charOffset, problem.message);
+      deprecated_addCompileTimeError(charOffset, problem.deprecated_message);
     } else {
-      warningNotError(
+      deprecated_warningNotError(
           "Not a type: '${builder.fullNameForErrors}'.", charOffset);
     }
     // TODO(ahe): Create an error somehow.
     return const InvalidType();
   }
 
   @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) {
-        internalError("Unexpected: $name.length");
+        deprecated_internalProblem("Unexpected: $name.length");
       }
       var prefix = name[0];
       if (prefix is Identifier) {
         prefix = prefix.name;
       }
       var suffix = name[1];
       if (suffix is Identifier) {
         suffix = suffix.name;
       }
       Builder builder;
       if (prefix is Builder) {
         builder = prefix;
       } else {
         builder = scope.lookup(prefix, beginToken.charOffset, uri);
       }
       if (builder is PrefixBuilder) {
         name = scopeLookup(builder.exports, suffix, beginToken,
             isQualified: true, prefix: builder);
       } else {
         push(const InvalidType());
-        addCompileTimeError(beginToken.charOffset,
+        deprecated_addCompileTimeError(beginToken.charOffset,
             "Can't be used as a type: '${debugName(prefix, suffix)}'.");
         return;
       }
     }
     if (name is Identifier) {
       name = name.name;
     }
     if (name is TypeDeclarationAccessor) {
       push(name.buildType(arguments));
     } else if (name is FastaAccessor) {
-      warningNotError(
+      deprecated_warningNotError(
           "'${beginToken.lexeme}' isn't a type.", 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 {
-      internalError("Unhandled: '${name.runtimeType}'.");
+      deprecated_internalProblem("Unhandled: '${name.runtimeType}'.");
     }
   }
 
   @override
   void beginFunctionType(Token beginToken) {
     debugEvent("beginFunctionType");
     enterFunctionTypeScope();
   }
 
   void enterFunctionTypeScope() {
     List typeVariables = pop();
     enterLocalScope(scope.createNestedScope(isModifiable: false));
     push(typeVariables ?? NullValue.TypeVariables);
     if (typeVariables != null) {
       ScopeBuilder scopeBuilder = new ScopeBuilder(scope);
       for (KernelTypeVariableBuilder builder in typeVariables) {
         String name = builder.name;
         KernelTypeVariableBuilder existing = scopeBuilder[name];
         if (existing == null) {
           scopeBuilder.addMember(name, builder);
         } else {
-          addCompileTimeError(
+          deprecated_addCompileTimeError(
               builder.charOffset, "'$name' already declared in this scope.");
-          addCompileTimeError(
+          deprecated_addCompileTimeError(
               existing.charOffset, "Previous definition of '$name'.");
         }
       }
     }
   }
 
   @override
   void endFunctionType(Token functionToken, Token endToken) {
     debugEvent("FunctionType");
     FormalParameters formals = pop();
     DartType returnType = pop();
     List<TypeParameter> typeVariables = typeVariableBuildersToKernel(pop());
     FunctionType type = formals.toFunctionType(returnType, typeVariables);
     exitLocalScope();
     push(type);
   }
 
   @override
   void handleVoidKeyword(Token token) {
     debugEvent("VoidKeyword");
     push(const VoidType());
   }
 
   @override
   void handleAsOperator(Token operator, Token endToken) {
     debugEvent("AsOperator");
     DartType type = pop();
     Expression expression = popForValue();
     if (constantExpressionRequired) {
-      push(buildCompileTimeError(
+      push(deprecated_buildCompileTimeError(
           "Not a constant expression.", operator.charOffset));
     } else {
       push(new KernelAsExpression(expression, type)
         ..fileOffset = offsetForToken(operator));
     }
   }
 
   @override
   void handleIsOperator(Token operator, Token not, Token endToken) {
     debugEvent("IsOperator");
     DartType type = pop();
     Expression operand = popForValue();
     bool isInverted = not != null;
     var offset = offsetForToken(operator);
     Expression isExpression = isInverted
         ? new KernelIsNotExpression(operand, type, offset)
         : new KernelIsExpression(operand, type)
       ..fileOffset = offset;
     if (operand is VariableGet) {
       typePromoter.handleIsCheck(isExpression, isInverted, operand.variable,
           type, functionNestingLevel);
     }
     if (constantExpressionRequired) {
-      push(buildCompileTimeError(
+      push(deprecated_buildCompileTimeError(
           "Not a constant expression.", operator.charOffset));
     } else {
       push(isExpression);
     }
   }
 
   @override
   void handleConditionalExpression(Token question, Token colon) {
     debugEvent("ConditionalExpression");
     Expression elseExpression = popForValue();
     Expression thenExpression = popForValue();
     Expression condition = popForValue();
     push(new KernelConditionalExpression(
         condition, thenExpression, elseExpression));
   }
 
   @override
   void endThrowExpression(Token throwToken, Token endToken) {
     debugEvent("ThrowExpression");
     Expression expression = popForValue();
     if (constantExpressionRequired) {
-      push(buildCompileTimeError(
+      push(deprecated_buildCompileTimeError(
           "Not a constant expression.", throwToken.charOffset));
     } else {
       push(
           new KernelThrow(expression)..fileOffset = offsetForToken(throwToken));
     }
   }
 
   @override
   void endFormalParameter(Token thisKeyword, Token nameToken,
       FormalParameterType kind, MemberKind memberKind) {
     debugEvent("FormalParameter");
     if (thisKeyword != null) {
       if (!inConstructor) {
-        addCompileTimeError(thisKeyword.charOffset,
+        deprecated_addCompileTimeError(thisKeyword.charOffset,
             "'this' parameters can only be used on constructors.");
         thisKeyword = null;
       }
     }
     Identifier name = pop();
     DartType type = pop();
     int modifiers = Modifier.validate(pop());
     if (inCatchClause) {
       modifiers |= finalMask;
     }
     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) {
-        internalError("Internal error: formal missing for '${name.name}'");
+        deprecated_internalProblem(
+            "Internal error: formal missing for '${name.name}'");
       } 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 109 matching lines @@
         exception = catchParameters.required[0];
         exception.type = type;
       }
       if (catchParameters.required.length > 1) {
         stackTrace = catchParameters.required[1];
         stackTrace.type = coreTypes.stackTraceClass.rawType;
       }
       if (catchParameters.required.length > 2 ||
           catchParameters.optional != null) {
         body = new Block(<Statement>[
-          compileTimeErrorInTry ??= buildCompileTimeErrorStatement(
+          compileTimeErrorInTry ??= deprecated_buildCompileTimeErrorStatement(
               "Invalid catch arguments.", catchKeyword.next.charOffset)
         ]);
       }
     }
     push(new Catch(exception, body, guard: type, stackTrace: stackTrace));
   }
 
   @override
   void endTryStatement(int catchCount, Token tryKeyword, Token finallyKeyword) {
     Statement finallyBlock = popStatementIfNotNull(finallyKeyword);
@@ skipping 59 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 internalError("Unknown increment operator: ${token.lexeme}");
+    return deprecated_internalProblem(
+        "Unknown increment operator: ${token.lexeme}");
   }
 
   @override
   void handleUnaryPrefixAssignmentExpression(Token token) {
     debugEvent("UnaryPrefixAssignmentExpression");
     var accessor = pop();
     if (accessor is FastaAccessor) {
       push(accessor.buildPrefixIncrement(incrementOperator(token),
           offset: token.charOffset));
     } else {
-      push(wrapInCompileTimeError(toValue(accessor), "Can't assign to this."));
+      push(deprecated_wrapInCompileTimeError(
+          toValue(accessor), "Can't assign to this."));
     }
   }
 
   @override
   void handleUnaryPostfixAssignmentExpression(Token token) {
     debugEvent("UnaryPostfixAssignmentExpression");
     var accessor = pop();
     if (accessor is FastaAccessor) {
       push(new DelayedPostfixIncrement(
           this, token, accessor, incrementOperator(token), null));
     } else {
-      push(wrapInCompileTimeError(toValue(accessor), "Can't assign to this."));
+      push(deprecated_wrapInCompileTimeError(
+          toValue(accessor), "Can't assign to this."));
     }
   }
 
   @override
   void endConstructorReference(
       Token start, Token periodBeforeName, Token endToken) {
     debugEvent("ConstructorReference");
     pushQualifiedReference(start, periodBeforeName);
   }
 
@@ skipping 71 matching lines @@
     if (target is Constructor) {
       assert(!target.enclosingClass.isAbstract);
       typeParameters = target.enclosingClass.typeParameters;
     }
     if (!checkArguments(target.function, arguments, typeParameters)) {
       return throwNoSuchMethodError(new NullLiteral()..fileOffset = charOffset,
           target.name.name, arguments, charOffset);
     }
     if (target is Constructor) {
       if (isConst && !target.isConst) {
-        return buildCompileTimeError("Not a const constructor.", charOffset);
+        return deprecated_buildCompileTimeError(
+            "Not a const constructor.", charOffset);
       }
       return new KernelConstructorInvocation(target, initialTarget, arguments,
           isConst: isConst)
         ..fileOffset = charOffset;
     } else {
       Procedure procedure = target;
       if (isConst && !procedure.isConst) {
-        return buildCompileTimeError("Not a const factory.", charOffset);
+        return deprecated_buildCompileTimeError(
+            "Not a const factory.", charOffset);
       } else if (procedure.isFactory) {
         return new KernelFactoryConstructorInvocation(
             target, initialTarget, arguments,
             isConst: isConst)
           ..fileOffset = charOffset;
       } else {
         return new KernelStaticInvocation(target, arguments, isConst: isConst)
           ..fileOffset = charOffset;
       }
     }
@@ skipping 30 matching lines @@
     }
 
     return true;
   }
 
   @override
   void beginNewExpression(Token token) {
     debugEvent("beginNewExpression");
     super.push(constantExpressionRequired);
     if (constantExpressionRequired) {
-      addCompileTimeError(token.charOffset, "Not a constant expression.");
+      deprecated_addCompileTimeError(
+          token.charOffset, "Not a constant expression.");
     }
     constantExpressionRequired = false;
   }
 
   @override
   void beginConstExpression(Token token) {
     debugEvent("beginConstExpression");
     super.push(constantExpressionRequired);
     constantExpressionRequired = true;
   }
@@ skipping 21 matching lines @@
     String name = pop();
     List<DartType> typeArguments = pop();
     var type = pop();
     if (type is TypeDeclarationAccessor) {
       TypeDeclarationAccessor accessor = type;
       type = accessor.declaration;
     }
     bool savedConstantExpressionRequired = pop();
     () {
       if (arguments == null) {
-        push(buildCompileTimeError("No arguments.", nameToken.charOffset));
+        push(deprecated_buildCompileTimeError(
+            "No arguments.", nameToken.charOffset));
         return;
       }
 
       if (typeArguments != null) {
         assert(arguments.types.isEmpty);
         KernelArguments.setExplicitArgumentTypes(arguments, typeArguments);
       }
 
       String errorName;
       if (type is ClassBuilder) {
         if (type is EnumBuilder) {
-          push(buildCompileTimeError(
+          push(deprecated_buildCompileTimeError(
               "An enum class can't be instantiated.", nameToken.charOffset));
           return;
         }
         Builder b =
             type.findConstructorOrFactory(name, token.charOffset, uri, library);
         Member target;
         Member initialTarget;
         if (b == null) {
           // Not found. Reported below.
         } else if (b.isConstructor) {
           initialTarget = b.target;
           if (type.isAbstract) {
             push(new KernelSyntheticExpression(evaluateArgumentsBefore(
                 arguments,
                 buildAbstractClassInstantiationError(
                     type.name, nameToken.charOffset))));
             return;
           } else {
             target = initialTarget;
           }
         } else if (b.isFactory) {
           initialTarget = b.target;
           target = getRedirectionTarget(initialTarget);
           if (target == null) {
-            push(buildCompileTimeError(
+            push(deprecated_buildCompileTimeError(
                 "Cyclic definition of factory '${name}'.",
                 nameToken.charOffset));
             return;
           }
           RedirectingFactoryBody body = getRedirectingFactoryBody(target);
           if (body != null) {
             // If the redirection target is itself a redirecting factory, it
             // means that it is unresolved. So we set target to null so we
             // can generate a no-such-method error below.
             assert(body.isUnresolved);
@@ skipping 35 matching lines @@
     debugEvent("TypeArguments");
     push(popList(count));
   }
 
   @override
   void handleThisExpression(Token token, IdentifierContext context) {
     debugEvent("ThisExpression");
     if (context.isScopeReference && isInstanceContext) {
       push(new ThisAccessor(this, token, inInitializer));
     } else {
-      push(new IncompleteError(
+      push(new deprecated_IncompleteError(
           this, token, "Expected identifier, but got 'this'."));
     }
   }
 
   @override
   void handleSuperExpression(Token token, IdentifierContext context) {
     debugEvent("SuperExpression");
     if (context.isScopeReference && isInstanceContext) {
       Member member = this.member.target;
       member.transformerFlags |= TransformerFlag.superCalls;
       push(new ThisAccessor(this, token, inInitializer, isSuper: true));
     } else {
-      push(new IncompleteError(
+      push(new deprecated_IncompleteError(
           this, token, "Expected identifier, but got 'super'."));
     }
   }
 
   @override
   void handleNamedArgument(Token colon) {
     debugEvent("NamedArgument");
     Expression value = popForValue();
     Identifier identifier = pop();
     push(new NamedExpression(identifier.name, value)
       ..fileOffset = offsetForToken(identifier.token));
   }
 
   @override
   void endFunctionName(Token beginToken, Token token) {
     debugEvent("FunctionName");
     Identifier name = pop();
     VariableDeclaration variable = new KernelVariableDeclaration(
         name.name, functionNestingLevel,
         isFinal: true, isLocalFunction: true)
       ..fileOffset = offsetForToken(name.token);
     if (scope.local[variable.name] != null) {
-      addCompileTimeError(offsetForToken(name.token),
+      deprecated_addCompileTimeError(offsetForToken(name.token),
           "'${variable.name}' already declared in this scope.");
     }
     push(new KernelFunctionDeclaration(
         variable,
         // The function node is created later.
         null)
       ..fileOffset = beginToken.charOffset);
     declareVariable(variable);
     enterLocalScope();
   }
@@ skipping 78 matching lines @@
     AsyncMarker asyncModifier = pop();
     exitLocalScope();
     FormalParameters formals = pop();
     exitFunction();
     List<TypeParameter> typeParameters = typeVariableBuildersToKernel(pop());
     FunctionNode function = formals.addToFunction(new FunctionNode(body,
         typeParameters: typeParameters, asyncMarker: asyncModifier)
       ..fileOffset = beginToken.charOffset
       ..fileEndOffset = token.charOffset);
     if (constantExpressionRequired) {
-      push(buildCompileTimeError(
+      push(deprecated_buildCompileTimeError(
           "Not a constant expression.", formals.charOffset));
     } else {
       push(new KernelFunctionExpression(function)
         ..fileOffset = offsetForToken(beginToken));
     }
   }
 
   @override
   void endDoWhileStatement(
       Token doKeyword, Token whileKeyword, Token endToken) {
@@ skipping 40 matching lines @@
     if (continueTarget.hasUsers) {
       body = new KernelLabeledStatement(body);
       continueTarget.resolveContinues(body);
     }
     VariableDeclaration variable;
     bool declaresVariable = false;
     if (lvalue is VariableDeclaration) {
       declaresVariable = true;
       variable = lvalue;
       if (variable.isConst) {
-        addCompileTimeError(
+        deprecated_addCompileTimeError(
             variable.fileOffset, "A for-in loop-variable can't be 'const'.");
       }
     } else if (lvalue is FastaAccessor) {
       /// We are in this case, where `lvalue` isn't a [VariableDeclaration]:
       ///
       ///     for (lvalue in expression) body
       ///
       /// This is normalized to:
       ///
       ///     for (final #t in expression) {
       ///       lvalue = #t;
       ///       body;
       ///     }
       variable = new VariableDeclaration.forValue(null);
       body = combineStatements(
           new KernelSyntheticStatement(new ExpressionStatement(lvalue
               .buildAssignment(new VariableGet(variable), voidContext: true))),
           body);
     } else {
-      variable = new VariableDeclaration.forValue(buildCompileTimeError(
-          "Expected lvalue, but got ${lvalue}", forToken.next.next.charOffset));
+      variable = new VariableDeclaration.forValue(
+          deprecated_buildCompileTimeError("Expected lvalue, but got ${lvalue}",
+              forToken.next.next.charOffset));
     }
     Statement result = new KernelForInStatement(
         variable, expression, body, declaresVariable,
         isAsync: awaitToken != null)
       ..fileOffset = body.fileOffset;
     if (breakTarget.hasUsers) {
       result = new KernelLabeledStatement(result);
       breakTarget.resolveBreaks(result);
     }
     exitLoopOrSwitch(result);
@@ skipping 40 matching lines @@
     push(statement);
   }
 
   @override
   void endRethrowStatement(Token rethrowToken, Token endToken) {
     debugEvent("RethrowStatement");
     if (inCatchBlock) {
       push(new KernelExpressionStatement(
           new KernelRethrow()..fileOffset = offsetForToken(rethrowToken)));
     } else {
-      push(buildCompileTimeErrorStatement(
+      push(deprecated_buildCompileTimeErrorStatement(
           "'rethrow' can only be used in catch clauses.",
           rethrowToken.charOffset));
     }
   }
 
   @override
   void handleFinallyBlock(Token finallyKeyword) {
     debugEvent("FinallyBlock");
     // Do nothing, handled by [endTryStatement].
   }
@@ skipping 41 matching lines @@
     AssertStatement statement = new KernelAssertStatement(condition,
         conditionStartOffset: leftParenthesis.offset + 1,
         conditionEndOffset: rightParenthesis.offset,
         message: message);
     switch (kind) {
       case Assert.Statement:
         push(statement);
         break;
 
       case Assert.Expression:
-        push(buildCompileTimeError("`assert` can't be used as an expression."));
+        push(deprecated_buildCompileTimeError(
+            "`assert` can't be used as an expression."));
         break;
 
       case Assert.Initializer:
         push(buildAssertInitializer(statement));
         break;
     }
   }
 
   Initializer buildAssertInitializer(AssertStatement statement) {
     // Since kernel only has asserts in statment form, we convert it to an
@@ skipping 106 matching lines @@
           target.resolveGotos(current);
         }
       }
     }
     // Check all but the last case for the following:
     // 1. That it isn't a default case (which should be last).
     // 2. That it doesn't fall through to the next case.
     for (int i = 0; i < caseCount - 1; i++) {
       SwitchCase current = cases[i];
       if (current.isDefault) {
-        addCompileTimeError(current.fileOffset,
+        deprecated_addCompileTimeError(current.fileOffset,
             "'default' switch case should be the last case.");
         continue;
       }
       Block block = current.body;
       // [block] is a synthetic block that is added to handle variable
       // declarations in the switch case.
       TreeNode lastNode =
           block.statements.isEmpty ? null : block.statements.last;
       if (lastNode is Block) {
         // This is a non-synthetic block.
@@ skipping 36 matching lines @@
       bool hasTarget, Token breakKeyword, Token endToken) {
     debugEvent("BreakStatement");
     var target = breakTarget;
     String name;
     if (hasTarget) {
       Identifier identifier = pop();
       name = identifier.name;
       target = scope.lookupLabel(identifier.name);
     }
     if (target == null && name == null) {
-      push(compileTimeErrorInLoopOrSwitch = buildCompileTimeErrorStatement(
-          "No target of break.", breakKeyword.charOffset));
+      push(compileTimeErrorInLoopOrSwitch =
+          deprecated_buildCompileTimeErrorStatement(
+              "No target of break.", breakKeyword.charOffset));
     } else if (target == null ||
         target is! JumpTarget ||
         !target.isBreakTarget) {
-      push(compileTimeErrorInLoopOrSwitch = buildCompileTimeErrorStatement(
-          "Can't break to '$name'.", breakKeyword.next.charOffset));
+      push(compileTimeErrorInLoopOrSwitch =
+          deprecated_buildCompileTimeErrorStatement(
+              "Can't break to '$name'.", breakKeyword.next.charOffset));
     } else if (target.functionNestingLevel != functionNestingLevel) {
-      push(compileTimeErrorInLoopOrSwitch = buildCompileTimeErrorStatement(
-          "Can't break to '$name' in a different function.",
-          breakKeyword.next.charOffset));
+      push(compileTimeErrorInLoopOrSwitch =
+          deprecated_buildCompileTimeErrorStatement(
+              "Can't break to '$name' in a different function.",
+              breakKeyword.next.charOffset));
     } else {
       BreakStatement statement = new KernelBreakStatement(null)
         ..fileOffset = breakKeyword.charOffset;
       target.addBreak(statement);
       push(statement);
     }
   }
 
   @override
   void handleContinueStatement(
       bool hasTarget, Token continueKeyword, Token endToken) {
     debugEvent("ContinueStatement");
     var target = continueTarget;
     String name;
     if (hasTarget) {
       Identifier identifier = pop();
       name = identifier.name;
       target = scope.lookupLabel(identifier.name);
       if (target != null && target is! JumpTarget) {
-        push(compileTimeErrorInLoopOrSwitch = buildCompileTimeErrorStatement(
-            "Target of continue must be a label.", continueKeyword.charOffset));
+        push(compileTimeErrorInLoopOrSwitch =
+            deprecated_buildCompileTimeErrorStatement(
+                "Target of continue must be a label.",
+                continueKeyword.charOffset));
         return;
       }
       if (target == null) {
         if (switchScope == null) {
-          push(buildCompileTimeErrorStatement(
+          push(deprecated_buildCompileTimeErrorStatement(
               "Can't find label '$name'.", continueKeyword.next.charOffset));
           return;
         }
         switchScope.forwardDeclareLabel(identifier.name,
             target = createGotoTarget(offsetForToken(identifier.token)));
       }
       if (target.isGotoTarget &&
           target.functionNestingLevel == functionNestingLevel) {
         ContinueSwitchStatement statement =
             new KernelContinueSwitchStatement(null);
         target.addGoto(statement);
         push(statement);
         return;
       }
     }
     if (target == null) {
-      push(compileTimeErrorInLoopOrSwitch = buildCompileTimeErrorStatement(
-          "No target of continue.", continueKeyword.charOffset));
+      push(compileTimeErrorInLoopOrSwitch =
+          deprecated_buildCompileTimeErrorStatement(
+              "No target of continue.", continueKeyword.charOffset));
     } else if (!target.isContinueTarget) {
-      push(compileTimeErrorInLoopOrSwitch = buildCompileTimeErrorStatement(
-          "Can't continue at '$name'.", continueKeyword.next.charOffset));
+      push(compileTimeErrorInLoopOrSwitch =
+          deprecated_buildCompileTimeErrorStatement(
+              "Can't continue at '$name'.", continueKeyword.next.charOffset));
     } else if (target.functionNestingLevel != functionNestingLevel) {
-      push(compileTimeErrorInLoopOrSwitch = buildCompileTimeErrorStatement(
-          "Can't continue at '$name' in a different function.",
-          continueKeyword.next.charOffset));
+      push(compileTimeErrorInLoopOrSwitch =
+          deprecated_buildCompileTimeErrorStatement(
+              "Can't continue at '$name' in a different function.",
+              continueKeyword.next.charOffset));
     } else {
       BreakStatement statement = new KernelBreakStatement(null)
         ..fileOffset = continueKeyword.charOffset;
       target.addContinue(statement);
       push(statement);
     }
   }
 
   @override
   void endTypeVariable(Token token, Token extendsOrSuper) {
     debugEvent("TypeVariable");
     DartType bound = pop();
     if (bound != null) {
       // TODO(ahe): To handle F-bounded types, this needs to be a TypeBuilder.
-      warningNotError("Type variable bounds not implemented yet.",
+      deprecated_warningNotError("Type variable bounds not implemented yet.",
           offsetForToken(extendsOrSuper.next));
     }
     Identifier name = pop();
     // TODO(ahe): Do not discard metadata.
     pop(); // Metadata.
     push(new KernelTypeVariableBuilder(
         name.name, library, offsetForToken(name.token), null)
       ..finish(library, library.loader.coreLibrary["Object"]));
   }
 
@@ skipping 27 matching lines @@
     debugEvent("Modifiers");
     // TODO(ahe): Copied from outline_builder.dart.
     push(popList(count) ?? NullValue.Modifiers);
   }
 
   @override
   void handleRecoverableError(Token token, FastaMessage message) {
     bool silent = hasParserError ||
         message.code == codeFinalFieldWithoutInitializer ||
         message.code == codeConstFieldWithoutInitializer;
-    addCompileTimeError(message.charOffset, message.message, silent: silent);
+    deprecated_addCompileTimeError(message.charOffset, message.message,
+        silent: silent);
   }
 
   @override
   Token handleUnrecoverableError(Token token, FastaMessage message) {
     if (enableNative && message.code == codeExpectedFunctionBody) {
       Token recover = skipNativeClause(token, stringExpectedAfterNative);
       if (recover != null) return recover;
     } else if (message.code == codeExpectedButGot) {
       String expected = message.arguments["string"];
       const List<String> trailing = const <String>[")", "}", ";", ","];
       if (trailing.contains(token.stringValue) && trailing.contains(expected)) {
         handleRecoverableError(token, message);
         return newSyntheticToken(token);
       }
     }
     return super.handleUnrecoverableError(token, message);
   }
 
   @override
-  Expression buildCompileTimeError(error, [int charOffset = -1]) {
+  Expression deprecated_buildCompileTimeError(error, [int charOffset = -1]) {
     // TODO(ahe): This method should be passed the erroneous expression, wrap
     // it in a class (TBD) from which the erroneous expression can be easily
     // extracted. Similar for statements and initializers. See also [issue
     // 29717](https://github.com/dart-lang/sdk/issues/29717)
-    addCompileTimeError(charOffset, error, wasHandled: true);
+    deprecated_addCompileTimeError(charOffset, error, wasHandled: true);
     return new KernelSyntheticExpression(library.loader
-        .throwCompileConstantError(library.loader.buildCompileTimeError(
-            formatUnexpected(uri, charOffset, error), charOffset)));
+        .throwCompileConstantError(library.loader
+            .deprecated_buildCompileTimeError(
+                deprecated_formatUnexpected(uri, charOffset, error),
+                charOffset)));
   }
 
-  Expression wrapInCompileTimeError(Expression expression, String message) {
+  Expression deprecated_wrapInCompileTimeError(
+      Expression expression, String message) {
     return new Let(
         new VariableDeclaration.forValue(expression)
           ..fileOffset = expression.fileOffset,
-        buildCompileTimeError(message, expression.fileOffset))
+        deprecated_buildCompileTimeError(message, expression.fileOffset))
       ..fileOffset = expression.fileOffset;
   }
 
   Expression buildFallThroughError(int charOffset) {
-    warningNotError("Switch case may fall through to next case.", charOffset);
+    deprecated_warningNotError(
+        "Switch case may fall through to next case.", charOffset);
 
     Location location = messages.getLocationFromUri(uri, charOffset);
 
     return new Throw(buildStaticInvocation(
         library.loader.coreTypes.fallThroughErrorUrlAndLineConstructor,
         new Arguments(<Expression>[
           new StringLiteral(location?.file ?? uri.toString()),
           new IntLiteral(location?.line ?? 0)
         ]),
         charOffset: charOffset));
   }
 
   Expression buildAbstractClassInstantiationError(String className,
       [int charOffset = -1]) {
-    warning("The class '$className' is abstract and can't be instantiated.",
+    deprecated_warning(
+        "The class '$className' is abstract and can't be instantiated.",
         charOffset);
     Builder constructor = library.loader.getAbstractClassInstantiationError();
     return new Throw(buildStaticInvocation(constructor.target,
         new KernelArguments(<Expression>[new StringLiteral(className)])));
   }
 
-  Statement buildCompileTimeErrorStatement(error, [int charOffset = -1]) {
+  Statement deprecated_buildCompileTimeErrorStatement(error,
+      [int charOffset = -1]) {
     return new KernelExpressionStatement(
-        buildCompileTimeError(error, charOffset));
+        deprecated_buildCompileTimeError(error, charOffset));
   }
 
   @override
   Initializer buildInvalidInitializer(Expression expression,
       [int charOffset = -1]) {
     needsImplicitSuperInitializer = false;
     return new LocalInitializer(new VariableDeclaration.forValue(expression))
       ..fileOffset = charOffset;
   }
 
   Initializer buildDuplicatedInitializer(
       String name, int offset, int previousInitializerOffset) {
     Initializer initializer = buildInvalidInitializer(
-        buildCompileTimeError("'$name' has already been initialized.", offset),
+        deprecated_buildCompileTimeError(
+            "'$name' has already been initialized.", offset),
         offset);
-    addCompileTimeError(
+    deprecated_addCompileTimeError(
         initializedFields[name], "'$name' was initialized here.");
     return initializer;
   }
 
   @override
   Initializer buildFieldInitializer(
       String name, int offset, Expression expression) {
     Builder builder = classBuilder.scope.local[name];
     if (builder is KernelFieldBuilder && builder.isInstanceMember) {
       initializedFields ??= <String, int>{};
       if (initializedFields.containsKey(name)) {
         return buildDuplicatedInitializer(
             name, offset, initializedFields[name]);
       }
       initializedFields[name] = offset;
       if (builder.isFinal && builder.hasInitializer) {
         // TODO(ahe): If CL 2843733002 is landed, this becomes a compile-time
         // error. Also, this is a compile-time error in strong mode.
-        warningNotError(
+        deprecated_warningNotError(
             "'$name' is final instance variable that has already been "
             "initialized.",
             offset);
-        warningNotError("'$name' was initialized here.", builder.charOffset);
+        deprecated_warningNotError(
+            "'$name' was initialized here.", builder.charOffset);
         Builder constructor =
             library.loader.getDuplicatedFieldInitializerError();
         return buildInvalidInitializer(
             new Throw(buildStaticInvocation(constructor.target,
                 new Arguments(<Expression>[new StringLiteral(name)]),
                 charOffset: offset)),
             offset);
       } else {
         return new FieldInitializer(builder.field, expression)
           ..fileOffset = offset;
       }
     } else {
       return buildInvalidInitializer(
-          buildCompileTimeError(
+          deprecated_buildCompileTimeError(
               "'$name' isn't an instance field of this class.", offset),
           offset);
     }
   }
 
   @override
   Initializer buildSuperInitializer(
       Constructor constructor, Arguments arguments,
       [int charOffset = -1]) {
     if (member.isConst && !constructor.isConst) {
       return buildInvalidInitializer(
-          buildCompileTimeError("Super constructor isn't const.", charOffset),
+          deprecated_buildCompileTimeError(
+              "Super constructor isn't const.", charOffset),
           charOffset);
     }
     needsImplicitSuperInitializer = false;
     return new SuperInitializer(constructor, arguments)
       ..fileOffset = charOffset;
   }
 
   @override
   Initializer buildRedirectingInitializer(
       Constructor constructor, Arguments arguments,
       [int charOffset = -1]) {
     needsImplicitSuperInitializer = false;
     return new KernelRedirectingInitializer(constructor, arguments)
       ..fileOffset = charOffset;
   }
 
   @override
   Expression buildProblemExpression(ProblemBuilder builder, int charOffset) {
-    return buildCompileTimeError(builder.message, charOffset);
+    return deprecated_buildCompileTimeError(
+        builder.deprecated_message, charOffset);
   }
 
   @override
   void handleOperator(Token token) {
     debugEvent("Operator");
     push(new Operator(token.stringValue, token.charOffset));
   }
 
   @override
   void handleSymbolVoid(Token token) {
     debugEvent("SymbolVoid");
     push(new Identifier(token));
   }
 
   @override
-  dynamic addCompileTimeError(int charOffset, String message,
+  dynamic deprecated_addCompileTimeError(int charOffset, String message,
       {bool silent: false, bool wasHandled: false}) {
     // TODO(ahe): If constantExpressionRequired is set, set it to false to
     // avoid a long list of errors.
-    return library.addCompileTimeError(charOffset, message,
+    return library.deprecated_addCompileTimeError(charOffset, message,
         fileUri: uri, silent: silent, wasHandled: wasHandled);
   }
 
   @override
   void handleInvalidFunctionBody(Token token) {
     if (member.isNative) {
       push(NullValue.FunctionBody);
     } else {
       push(new Block(<Statement>[
-        buildCompileTimeErrorStatement("Expected '{'.", token.charOffset)
+        deprecated_buildCompileTimeErrorStatement(
+            "Expected '{'.", token.charOffset)
       ]));
     }
   }
 
   @override
-  void warning(String message, [int charOffset = -1]) {
+  void deprecated_warning(String message, [int charOffset = -1]) {
     if (constantExpressionRequired) {
-      addCompileTimeError(charOffset, message);
+      deprecated_addCompileTimeError(charOffset, message);
     } else {
-      super.warning(message, charOffset);
+      super.deprecated_warning(message, charOffset);
     }
   }
 
-  void warningNotError(String message, [int charOffset = -1]) {
-    super.warning(message, charOffset);
+  void deprecated_warningNotError(String message, [int charOffset = -1]) {
+    super.deprecated_warning(message, charOffset);
   }
 
   @override
   DartType validatedTypeVariableUse(
       TypeParameterType type, int offset, bool nonInstanceAccessIsError) {
     if (!isInstanceContext && type.parameter.parent is Class) {
       String message = "Type variables can't be used in static members.";
       if (nonInstanceAccessIsError) {
-        addCompileTimeError(offset, message);
+        deprecated_addCompileTimeError(offset, message);
       } else {
-        warning(message, offset);
+        deprecated_warning(message, offset);
       }
       return const InvalidType();
     } else if (constantExpressionRequired) {
-      addCompileTimeError(
+      deprecated_addCompileTimeError(
           offset,
           "Type variable '${type.parameter.name}' can't be used as a constant "
           "expression $type.");
     }
     return type;
   }
 
   Expression evaluateArgumentsBefore(
       Arguments arguments, Expression expression) {
     if (arguments == null) return expression;
@@ skipping 13 matching lines @@
   @override
   bool isIdentical(Member member) => member == coreTypes.identicalProcedure;
 
   @override
   Expression buildMethodInvocation(
       Expression receiver, Name name, Arguments arguments, int offset,
       {bool isConstantExpression: false,
       bool isNullAware: false,
       bool isImplicitCall: false}) {
     if (constantExpressionRequired && !isConstantExpression) {
-      return buildCompileTimeError("Not a constant expression.", offset);
+      return deprecated_buildCompileTimeError(
+          "Not a constant expression.", offset);
     }
     if (isNullAware) {
       VariableDeclaration variable = new VariableDeclaration.forValue(receiver);
       return new KernelNullAwareMethodInvocation(
           variable,
           new ConditionalExpression(
               buildIsNull(new VariableGet(variable), offset),
               new NullLiteral(),
               new MethodInvocation(new VariableGet(variable), name, arguments)
                 ..fileOffset = offset,
               null)
             ..fileOffset = offset)
         ..fileOffset = offset;
     } else {
       return new KernelMethodInvocation(receiver, name, arguments,
           isImplicitCall: isImplicitCall)
         ..fileOffset = offset;
     }
   }
 
   @override
   void addCompileTimeErrorFromMessage(FastaMessage message) {
-    library.addCompileTimeError(message.charOffset, message.message,
+    library.deprecated_addCompileTimeError(message.charOffset, message.message,
         fileUri: message.uri);
   }
 
   @override
   void debugEvent(String name) {
     // printEvent(name);
   }
 
   @override
   StaticGet makeStaticGet(Member readTarget, Token token) {
@@ skipping 40 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 => internalError("Unsupported operation.");
+  String get plainNameForRead =>
+      deprecated_internalProblem("Unsupported operation.");
 
   Expression doInvocation(int charOffset, Arguments arguments) {
-    return internalError("Unhandled: ${runtimeType}", uri, charOffset);
+    return deprecated_internalProblem(
+        "Unhandled: ${runtimeType}", uri, charOffset);
   }
 
   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() => internalError("not supported");
+  makeInvalidRead() => deprecated_internalProblem("not supported");
 
   Expression makeInvalidWrite(Expression value) {
-    return helper.buildCompileTimeError(
+    return helper.deprecated_buildCompileTimeError(
         "Can't be used as left-hand side of assignment.",
         offsetForToken(token));
   }
 }
 
 class DelayedAssignment extends ContextAccessor {
   final Expression value;
 
   final String assignmentOperator;
 
   DelayedAssignment(BuilderHelper helper, Token token, FastaAccessor accessor,
       this.value, this.assignmentOperator)
       : super(helper, token, accessor);
 
   Expression buildSimpleRead() {
     return handleAssignment(false);
   }
 
   Expression buildForEffect() {
     return handleAssignment(true);
   }
 
   Expression handleAssignment(bool voidContext) {
     if (helper.constantExpressionRequired) {
-      return helper.buildCompileTimeError(
+      return helper.deprecated_buildCompileTimeError(
           "Not a constant expression.", offsetForToken(token));
     }
     if (identical("=", assignmentOperator)) {
       return accessor.buildAssignment(value, voidContext: voidContext);
     } else if (identical("+=", assignmentOperator)) {
       return accessor.buildCompoundAssignment(plusName, value,
           offset: offsetForToken(token), voidContext: voidContext);
     } else if (identical("-=", assignmentOperator)) {
       return accessor.buildCompoundAssignment(minusName, value,
           offset: offsetForToken(token), voidContext: voidContext);
@@ skipping 22 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 internalError("Unhandled: $assignmentOperator");
+      return deprecated_internalProblem("Unhandled: $assignmentOperator");
     }
   }
 
   @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 => internalError("Unsupported operation.");
+  List<Statement> get users =>
+      deprecated_internalProblem("Unsupported operation.");
 
-  JumpTargetKind get kind => internalError("Unsupported operation.");
+  JumpTargetKind get kind =>
+      deprecated_internalProblem("Unsupported operation.");
 
   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) {
-    internalError("Unsupported operation.");
+    deprecated_internalProblem("Unsupported operation.");
   }
 
   void resolveBreaks(LabeledStatement target) {
     breakTarget.resolveBreaks(target);
   }
 
   void resolveContinues(LabeledStatement target) {
     continueTarget.resolveContinues(target);
   }
 
   void resolveGotos(SwitchCase target) {
-    internalError("Unsupported operation.");
+    deprecated_internalProblem("Unsupported operation.");
   }
 
   @override
   String get fullNameForErrors => "<label-target>";
 }
 
 class OptionalFormals {
   final FormalParameterType kind;
 
   final List<VariableDeclaration> formals;
@@ skipping 52 matching lines @@
         typeParameters: typeParameters);
   }
 
   Scope computeFormalParameterScope(
       Scope parent, Builder builder, BuilderHelper helper) {
     if (required.length == 0 && optional == null) return parent;
     Map<String, Builder> local = <String, Builder>{};
 
     for (VariableDeclaration parameter in required) {
       if (local[parameter.name] != null) {
-        helper.addCompileTimeError(parameter.fileOffset, "Duplicated name.");
+        helper.deprecated_addCompileTimeError(
+            parameter.fileOffset, "Duplicated name.");
       }
       local[parameter.name] =
           new KernelVariableBuilder(parameter, builder, builder.fileUri);
     }
     if (optional != null) {
       for (VariableDeclaration parameter in optional.formals) {
         if (local[parameter.name] != null) {
-          helper.addCompileTimeError(parameter.fileOffset, "Duplicated name.");
+          helper.deprecated_addCompileTimeError(
+              parameter.fileOffset, "Duplicated name.");
         }
         local[parameter.name] =
             new KernelVariableBuilder(parameter, builder, builder.fileUri);
       }
     }
     return new Scope(local, null, parent, isModifiable: false);
   }
 }
 
 /// Returns a block like this:
@@ skipping 22 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 internalError("Unhandled: ${node.runtimeType}");
+    return deprecated_internalProblem("Unhandled: ${node.runtimeType}");
   }
 }
 
 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 internalError("Unknown async modifier: $asyncToken");
+    return deprecated_internalProblem("Unknown async modifier: $asyncToken");
   }
 }