Deprecate all diagnostics methods that use strings.

pkg/front_end/lib/src/fasta/source/source_loader.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.source_loader;
 
 import 'dart:async' show Future;
 
 import 'dart:typed_data' show Uint8List;
 
@@ skipping 22 matching lines @@
     show
         Builder,
         ClassBuilder,
         EnumBuilder,
         LibraryBuilder,
         NamedTypeBuilder,
         TypeBuilder;
 
 import '../compiler_context.dart' show CompilerContext;
 
-import '../errors.dart' show inputError;
+import '../deprecated_problems.dart' show deprecated_inputError;
 
 import '../export.dart' show Export;
 
 import '../loader.dart' show Loader;
 
 import '../parser/class_member_parser.dart' show ClassMemberParser;
 
 import '../scanner.dart' show ErrorToken, ScannerResult, Token, scan;
 
 import 'diet_listener.dart' show DietListener;
@@ skipping 20 matching lines @@
   TypeInferenceEngine typeInferenceEngine;
 
   Instrumentation instrumentation;
 
   SourceLoader(this.fileSystem, KernelTarget target) : super(target);
 
   Future<Token> tokenize(SourceLibraryBuilder library,
       {bool suppressLexicalErrors: false}) async {
     Uri uri = library.fileUri;
     if (uri == null || uri.scheme != "file") {
-      return inputError(library.uri, -1, "Not found: ${library.uri}.");
+      return deprecated_inputError(
+          library.uri, -1, "Not found: ${library.uri}.");
     }
 
     // Get the library text from the cache, or read from the file system.
     List<int> bytes = sourceBytes[uri];
     if (bytes == null) {
       try {
         List<int> rawBytes = await fileSystem.entityForUri(uri).readAsBytes();
         Uint8List zeroTerminatedBytes = new Uint8List(rawBytes.length + 1);
         zeroTerminatedBytes.setRange(0, rawBytes.length, rawBytes);
         bytes = zeroTerminatedBytes;
         sourceBytes[uri] = bytes;
       } on FileSystemException catch (e) {
-        return inputError(uri, -1, e.message);
+        return deprecated_inputError(uri, -1, e.message);
       }
     }
 
     byteCount += bytes.length - 1;
     ScannerResult result = scan(bytes);
     Token token = result.tokens;
     if (!suppressLexicalErrors) {
       List<int> source = getSource(bytes);
       target.addSourceInformation(library.fileUri, result.lineStarts, source);
     }
     while (token is ErrorToken) {
       if (!suppressLexicalErrors) {
         ErrorToken error = token;
-        library.addCompileTimeError(token.charOffset, error.assertionMessage,
+        library.deprecated_addCompileTimeError(
+            token.charOffset, error.assertionMessage,
             fileUri: uri);
       }
       token = token.next;
     }
     return token;
   }
 
   List<int> getSource(List<int> bytes) {
     if (excludeSource) return const <int>[];
 
@@ skipping 242 matching lines @@
       if (reported.add(cls)) {
         List<ClassBuilder> involved = <ClassBuilder>[];
         for (ClassBuilder cls in cycles) {
           if (realCycles.containsKey(cls)) {
             involved.add(cls);
             reported.add(cls);
           }
         }
         String involvedString =
             involved.map((c) => c.fullNameForErrors).join("', '");
-        cls.addCompileTimeError(
+        cls.deprecated_addCompileTimeError(
             cls.charOffset,
             "'${cls.fullNameForErrors}' is a supertype of itself via "
             "'$involvedString'.");
       }
     });
     ticker.logMs("Found cycles");
     Set<ClassBuilder> blackListedClasses = new Set<ClassBuilder>.from([
       coreLibrary["bool"],
       coreLibrary["int"],
       coreLibrary["num"],
       coreLibrary["double"],
       coreLibrary["String"],
     ]);
     for (ClassBuilder cls in allClasses) {
       if (cls.library.loader != this) continue;
       Set<ClassBuilder> directSupertypes = new Set<ClassBuilder>();
       target.addDirectSupertype(cls, directSupertypes);
       for (ClassBuilder supertype in directSupertypes) {
         if (supertype is EnumBuilder) {
-          cls.addCompileTimeError(
+          cls.deprecated_addCompileTimeError(
               cls.charOffset,
               "'${supertype.name}' is an enum and can't be extended or "
               "implemented.");
         } else if (!canImplementRestrictedTypes(cls.library) &&
             blackListedClasses.contains(supertype)) {
-          cls.addCompileTimeError(
+          cls.deprecated_addCompileTimeError(
               cls.charOffset,
               "'${supertype.name}' is restricted and can't be extended or "
               "implemented.");
         }
       }
       TypeBuilder mixedInType = cls.mixedInType;
       if (mixedInType != null) {
         bool isClassBuilder = false;
         if (mixedInType is NamedTypeBuilder) {
           var builder = mixedInType.builder;
           if (builder is ClassBuilder) {
             isClassBuilder = true;
             for (Builder constructory in builder.constructors.local.values) {
               if (constructory.isConstructor && !constructory.isSynthetic) {
-                cls.addCompileTimeError(
+                cls.deprecated_addCompileTimeError(
                     cls.charOffset,
                     "Can't use '${builder.fullNameForErrors}' as a mixin "
                     "because it has constructors.");
-                builder.addCompileTimeError(
+                builder.deprecated_addCompileTimeError(
                     constructory.charOffset,
                     "This constructor prevents using "
                     "'${builder.fullNameForErrors}' as a mixin.");
               }
             }
           }
         }
         if (!isClassBuilder) {
-          cls.addCompileTimeError(cls.charOffset,
+          cls.deprecated_addCompileTimeError(cls.charOffset,
               "The type '${mixedInType.fullNameForErrors}' can't be mixed in.");
         }
       }
     }
     ticker.logMs("Checked restricted supertypes");
   }
 
   void buildProgram() {
     builders.forEach((Uri uri, LibraryBuilder library) {
       if (library is SourceLibraryBuilder) {
@@ skipping 76 matching lines @@
         isSuper: isSuper,
         isStatic: isStatic,
         isConstructor: isConstructor,
         isTopLevel: isTopLevel);
   }
 
   Expression throwCompileConstantError(Expression error) {
     return target.backendTarget.throwCompileConstantError(coreTypes, error);
   }
 
-  Expression buildCompileTimeError(String message, int offset) {
+  Expression deprecated_buildCompileTimeError(String message, int offset) {
     return target.backendTarget
         .buildCompileTimeError(coreTypes, message, offset);
   }
 }