Fix various parser bugs related to modifiers of top-level and class members.

dart/sdk/lib/_internal/compiler/implementation/warnings.dart

 // Copyright (c) 2011, 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.
 
 part of dart2js;
 
+const DONT_KNOW_HOW_TO_FIX = "";
+
 /**
  * The messages in this file should meet the following guide lines:
  *
  * 1. The message should start with exactly one of "Error", "Internal error",
  * "Warning", "Info", or "Hint" followed by a colon. It is crucial to users to
  * be able to locate errors in the midst of warnings.
  * TODO(ahe): Remove these prefixes from the error message.
  *
  * 2. After the colon, one space and a complete sentence starting with an
  * uppercase letter, and ending with a period.
@@ skipping 516 matching lines @@
 
   static const DualKind CANNOT_RESOLVE_GETTER = const DualKind(
       error: const MessageKind('Error: Cannot resolve getter.'),
       warning: const MessageKind('Warning: Cannot resolve getter.'));
 
   static const DualKind CANNOT_RESOLVE_SETTER = const DualKind(
       error: const MessageKind('Error: Cannot resolve setter.'),
       warning: const MessageKind('Warning: Cannot resolve setter.'));
 
   static const MessageKind VOID_NOT_ALLOWED = const MessageKind(
-      'Error: Type "void" is only allowed in a return type.');
+      "Error: Type 'void' can't be used here because it isn't a return type.",
+      howToFix: "Try removing 'void' keyword or replace it with 'var', 'final',"
+          " or a type.",
+      examples: const [
+          "void x; main() {}",
+          "foo(void x) {} main() { foo(null); }",
+      ]);
 
   static const MessageKind BEFORE_TOP_LEVEL = const MessageKind(
       'Error: Part header must come before top-level definitions.');
 
   static const MessageKind LIBRARY_NAME_MISMATCH = const MessageKind(
       'Warning: Expected part of library name "#{libraryName}".');
 
   static const MessageKind MISSING_PART_OF_TAG = const MessageKind(
       'Error: This file has no part-of tag, but it is being used as a part.');
 
@@ skipping 193 matching lines @@
           """
 // 'addAll' is misspelled.
 @MirrorsUsed(targets: 'dart.core.List.addAl')
 import 'dart:mirrors';
 
 main() {}
 """]);
 
   static const MessageKind READ_SCRIPT_ERROR = const MessageKind(
       "Error: Can't read '#{uri}' (#{exception}).",
+      // Don't know how to fix since the underlying error is unknown.
+      howToFix: DONT_KNOW_HOW_TO_FIX,
       examples: const [
           """
 // 'foo.dart' does not exist.
 import 'foo.dart';
 
 main() {}
 """]);
 
+  static const MessageKind EXTRANEOUS_MODIFIER = const MessageKind(
+      "Error: Can't have modifier '#{modifier}' here.",
+      howToFix: "Try removing '#{modifier}'.",
+      examples: const [
+          "var String foo; main(){}",
+          // "var get foo; main(){}",
+          "var set foo; main(){}",
+          "var final foo; main(){}",
+          "var var foo; main(){}",
+          "var const foo; main(){}",
+          "var abstract foo; main(){}",
+          "var static foo; main(){}",
+          "var external foo; main(){}",
+          "get var foo; main(){}",
+          "set var foo; main(){}",
+          "final var foo; main(){}",
+          "var var foo; main(){}",
+          "const var foo; main(){}",
+          "abstract var foo; main(){}",
+          "static var foo; main(){}",
+          "external var foo; main(){}"]);
+
+  static const MessageKind EXTRANEOUS_MODIFIER_REPLACE = const MessageKind(
+      "Error: Can't have modifier '#{modifier}' here.",
+      howToFix: "Try replacing modifier '#{modifier}' with 'var', 'final',"
+          " or a type.",
+      examples: const [
+          // "get foo; main(){}",
+          "set foo; main(){}",
+          "abstract foo; main(){}",
+          "static foo; main(){}",
+          "external foo; main(){}"]);
+
+  static const MessageKind BODY_EXPECTED = const MessageKind(
+      "Error: Expected a function body or '=>'.",
+      howToFix: "Try adding {}, or removing 'static' keyword.",

[Johnni Winther, 2013/09/02 11:02:08]

This is a bad how-to-fix if you haven't got a 'static' keyword in your code. Try
splitting this into a top-level/member warning.

[ahe, 2013/09/02 17:49:59]

I've added a todo and changed the suggestion to: "Try adding {}."

+      examples: const [
+          "main();"]);
+
   static const MessageKind COMPILER_CRASHED = const MessageKind(
       'Error: The compiler crashed when compiling this element.');
 
   static const MessageKind PLEASE_REPORT_THE_CRASH = const MessageKind('''
 The compiler is broken.
 
 When compiling the above element, the compiler crashed. It is not
 possible to tell if this is caused by a problem in your program or
 not. Regardless, the compiler should not crash.
 
@@ skipping 62 matching lines @@
 
   static const MessageKind PATCH_POINT_TO_CONSTRUCTOR = const MessageKind(
       'Info: This is the constructor patch "#{constructorName}".');
 
   static const MessageKind PATCH_POINT_TO_PARAMETER = const MessageKind(
       'Info: This is the patch parameter "#{parameterName}".');
 
   static const MessageKind PATCH_NON_EXISTING = const MessageKind(
       'Error: Origin does not exist for patch "#{name}".');
 
+  // TODO(ahe): Eventually, this error should be removed as it will be handled
+  // by the regular parser.
   static const MessageKind PATCH_NONPATCHABLE = const MessageKind(
       'Error: Only classes and functions can be patched.');
 
   static const MessageKind PATCH_NON_EXTERNAL = const MessageKind(
       'Error: Only external functions can be patched.');
 
   static const MessageKind PATCH_NON_CLASS = const MessageKind(
       'Error: Patching non-class with class patch "#{className}".');
 
   static const MessageKind PATCH_NON_GETTER = const MessageKind(
@@ skipping 22 matching lines @@
 
   toString() => template;
 
   Message message([Map arguments = const {}, bool terse = false]) {
     return new Message(this, arguments, terse);
   }
 
   CompilationError error([Map arguments = const {}, bool terse = false]) {
     return new CompilationError(this, arguments, terse);
   }
+
+  bool get hasHowToFix => howToFix != null && howToFix != DONT_KNOW_HOW_TO_FIX;
 }
 
 class DualKind {
   final MessageKind error;
   final MessageKind warning;
 
   const DualKind({this.error, this.warning});
 }
 
 class Message {
@@ skipping 10 matching lines @@
     if (message == null) {
       message = kind.template;
       arguments.forEach((key, value) {
         String string = slowToString(value);
         message = message.replaceAll('#{${key}}', string);
       });
       assert(invariant(
           CURRENT_ELEMENT_SPANNABLE,
           !message.contains(new RegExp(r'#\{.+\}')),
           message: 'Missing arguments in error message: "$message"'));
-      if (!terse && kind.howToFix != null) {
+      if (!terse && kind.hasHowToFix) {
         String howToFix = kind.howToFix;
         arguments.forEach((key, value) {
           String string = slowToString(value);
           howToFix = howToFix.replaceAll('#{${key}}', string);
         });
         message = '$message\n$howToFix';
       }
     }
     return message;
   }
@@ skipping 37 matching lines @@
 
 class CompileTimeConstantError extends Diagnostic {
   CompileTimeConstantError(MessageKind kind, Map arguments, bool terse)
     : super(kind, arguments, terse);
 }
 
 class CompilationError extends Diagnostic {
   CompilationError(MessageKind kind, Map arguments, bool terse)
     : super(kind, arguments, terse);
 }