Mark top-level error field as static.

pkg/kernel/lib/verifier.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 kernel.checks;
 
 import 'ast.dart';
 import 'transformations/flags.dart';
 
 void verifyProgram(Program program) {
   VerifyingVisitor.check(program);
@@ skipping 39 matching lines @@
   final List<VariableDeclaration> variableStack = <VariableDeclaration>[];
   final Map<Typedef, TypedefState> typedefState = <Typedef, TypedefState>{};
   bool classTypeParametersAreInScope = false;
 
   /// If true, relax certain checks for *outline* mode. For example, don't
   /// attempt to validate constructor initializers.
   bool isOutline = false;
 
   bool inCatchBlock = false;
 
+  Library currentLibrary;
+
   Member currentMember;
+
   Class currentClass;
+
   TreeNode currentParent;
 
   TreeNode get context => currentMember ?? currentClass;
 
   static void check(Program program) {
     program.accept(new VerifyingVisitor());
   }
 
   defaultTreeNode(TreeNode node) {
     visitChildren(node);
@@ skipping 108 matching lines @@
       for (var library in program.libraries) {
         library.members.forEach(undeclareMember);
         for (var class_ in library.classes) {
           class_.members.forEach(undeclareMember);
         }
       }
       variableStack.forEach(undeclareVariable);
     }
   }
 
+  void visitLibrary(Library node) {
+    currentLibrary = node;
+    super.visitLibrary(node);
+    currentLibrary = null;
+  }
+
   void checkTypedef(Typedef node) {
     var state = typedefState[node];
     if (state == TypedefState.Done) return;
     if (state == TypedefState.BeingChecked) {
       problem(node, "The typedef '$node' refers to itself", context: node);
     }
     assert(state == null);
     typedefState[node] = TypedefState.BeingChecked;
     var savedTypeParameters = typeParametersInScope;
     typeParametersInScope = node.typeParameters.toSet();
     var savedParent = currentParent;
     currentParent = node;
     // Visit children without checking the parent pointer on the typedef itself
     // since this can be called from a context other than its true parent.
     node.visitChildren(this);
     currentParent = savedParent;
     typeParametersInScope = savedTypeParameters;
     typedefState[node] = TypedefState.Done;
   }
 
   visitTypedef(Typedef node) {
     checkTypedef(node);
     // Enter and exit the node to check the parent pointer on the typedef node.
     exitParent(enterParent(node));
   }
 
   visitField(Field node) {
     currentMember = node;
     var oldParent = enterParent(node);
+    bool isTopLevel = node.parent == currentLibrary;
+    if (isTopLevel && !node.isStatic) {
+      problem(node, "The top-level field '${node.name.name}' should be static",
+          context: node);
+    }
+    if (node.isConst && !node.isStatic) {
+      problem(node, "The const field '${node.name.name}' should be static",
+          context: node);
+    }
     classTypeParametersAreInScope = !node.isStatic;
     node.initializer?.accept(this);
     node.type.accept(this);
     classTypeParametersAreInScope = false;
     visitList(node.annotations, this);
     exitParent(oldParent);
     currentMember = null;
   }
 
   visitProcedure(Procedure node) {
@@ skipping 372 matching lines @@
     var oldParent = parent;
     parent = node;
     node.visitChildren(this);
     parent = oldParent;
   }
 }
 
 void checkInitializers(Constructor constructor) {
   // TODO(ahe): I'll add more here in other CLs.
 }