Complain about built-in identifiers.

pkg/front_end/lib/src/fasta/parser/parser.dart

 // Copyright (c) 2012, 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.parser.parser;
 
 import '../scanner.dart' show ErrorToken;
 
 import '../scanner/recover.dart' show closeBraceFor, skipToEof;
 
@@ skipping 869 matching lines @@
       token = reportUnrecoverableError(token, ErrorKind.ExpectedString)?.next;
     }
     listener.handleStringPart(token);
     return token.next;
   }
 
   Token parseIdentifier(Token token, IdentifierContext context) {
     if (!token.isIdentifier()) {
       token =
           reportUnrecoverableError(token, ErrorKind.ExpectedIdentifier)?.next;
+    } else if (token.isBuiltInIdentifier) {
+      // It is a compile-time error if a built-in identifier is used as the
+      // declared name of a prefix, class, type parameter or type alias.
+      // It is a compile-time error to use a built-in identifier other than
+      // dynamic as a type annotation or type parameter.
+      switch (context) {

[Paul Berry, 2017/03/14 19:57:57]

Rather than put a switch statement here (which can be slow due to the fact that
it typically gets implemented as a sequence of equality checks), consider adding
a "disallowsBuiltInIdentifiers" field to the IdentifierContext class.  That way
this code turns into something like:

if (context.disallowsBuiltInIdentifiers) {
  if (context.inDeclaration) {
    reportRecoverableError(
        token, ErrorKind.BuiltInIdentifierInDeclaration);
  } else if (!optional("dynamic", token)) {
    reportRecoverableError(
        token, ErrorKind.BuiltInIdentifierAsType);
  }
}

[ahe, 2017/03/16 09:10:51]

Done.

+        case IdentifierContext.importPrefixDeclaration:
+        case IdentifierContext.typedefDeclaration:
+        case IdentifierContext.enumDeclaration:
+        case IdentifierContext.namedMixinDeclaration:
+        case IdentifierContext.classDeclaration:
+        case IdentifierContext.typeVariableDeclaration:
+          reportRecoverableError(
+              token, ErrorKind.BuiltInIdentifierInDeclaration);
+          break;
+
+        case IdentifierContext.typeReference:
+        case IdentifierContext.typeReferenceContinuation:
+          if (!optional("dynamic", token)) {

[Siggi Cherem (dart-lang), 2017/03/14 16:04:45]

+floitsch

just a heads up: this will need to be changed on the `void` CL (that makes
`void` a built-in and allows it as a type everywhere) or here if Florian lands
that change first.

[ahe, 2017/03/16 09:10:51]

Acknowledged.

+            reportRecoverableError(token, ErrorKind.BuiltInIdentifierAsType);
+          }
+          break;
+
+        default:
+          break;
+      }
     }
     listener.handleIdentifier(token, context);
     return token.next;
   }
 
   Token expect(String string, Token token) {
     if (!identical(string, token.stringValue)) {
       return reportUnrecoverableError(
           token, ErrorKind.ExpectedButGot, {"expected": string})?.next;
     }
@@ skipping 2698 matching lines @@
         break;
     }
     if (isRecoverable) {
       listener.handleRecoverableError(token, kind, arguments);
       return null;
     } else {
       return listener.handleUnrecoverableError(token, kind, arguments);
     }
   }
 }