Use static final empty Modifier instead of null.

lib/compiler/implementation/elements/elements.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('elements');
 
 #import('dart:uri');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
@@ skipping 99 matching lines @@
 class Element implements Spannable {
   final SourceString name;
   final ElementKind kind;
   final Element enclosingElement;
   Link<MetadataAnnotation> metadata = const EmptyLink<MetadataAnnotation>();
 
   Element(this.name, this.kind, this.enclosingElement) {
     assert(getLibrary() !== null);
   }
 
-  Modifiers get modifiers => null;
+  Modifiers get modifiers => Modifiers.EMPTY;
 
   Node parseNode(DiagnosticListener listener) {
     listener.cancel("Internal Error: $this.parseNode", token: position());
   }
 
   DartType computeType(Compiler compiler) {
     compiler.internalError("$this.computeType.", token: position());
   }
 
   void addMetadata(MetadataAnnotation annotation) {
     assert(annotation.annotatedElement === null);
     annotation.annotatedElement = this;
     metadata = metadata.prepend(annotation);
   }
 
   bool isFunction() => kind === ElementKind.FUNCTION;
   bool isConstructor() => isFactoryConstructor() || isGenerativeConstructor();
   bool isClosure() => false;
   bool isMember() {
     // Check that this element is defined in the scope of a Class.
     Element enclosing = enclosingElement;
     if (enclosing !== null &&
         enclosing.kind === ElementKind.COMPILATION_UNIT_OVERRIDE) {
       enclosing = enclosing.enclosingElement;
     }
     return enclosing !== null && enclosing.isClass();
   }
   bool isInstanceMember() => false;
-  bool isFactoryConstructor() => modifiers !== null && modifiers.isFactory();
+  bool isFactoryConstructor() => modifiers.isFactory();
   bool isGenerativeConstructor() => kind === ElementKind.GENERATIVE_CONSTRUCTOR;
   bool isGenerativeConstructorBody() =>
       kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY;
   bool isCompilationUnit() => kind === ElementKind.COMPILATION_UNIT;
   bool isClass() => kind === ElementKind.CLASS;
   bool isPrefix() => kind === ElementKind.PREFIX;
   bool isVariable() => kind === ElementKind.VARIABLE;
   bool isParameter() => kind === ElementKind.PARAMETER;
   bool isStatement() => kind === ElementKind.STATEMENT;
   bool isTypedef() => kind === ElementKind.TYPEDEF;
@@ skipping 62 matching lines @@
 
   // TODO(johnniwinther): This breaks for libraries (for which enclosing
   // elements are null) and is invalid for top level variable declarations for
   // which the enclosing element is a VariableDeclarations and not a compilation
   // unit.
   bool isTopLevel() {
     return enclosingElement !== null && enclosingElement.isCompilationUnit();
   }
 
   bool isAssignable() {
-    if (modifiers != null && modifiers.isFinalOrConst()) return false;
+    if (modifiers.isFinalOrConst()) return false;
     if (isFunction() || isGenerativeConstructor()) return false;
     return true;
   }
 
   Token position() => null;
 
   Token findMyName(Token token) {
     for (Token t = token; t.kind !== EOF_TOKEN; t = t.next) {
       if (t.value == name) return t;
     }
@@ skipping 555 matching lines @@
   FunctionSignature functionSignature;
 
   VariableListElement(ElementKind kind,
                       Modifiers this.modifiers,
                       Element enclosing)
     : super(null, kind, enclosing);
 
   VariableListElement.node(VariableDefinitions node,
                            ElementKind kind,
                            Element enclosing)
-    : super(null, kind, enclosing),
-      this.cachedNode = node,
-      this.modifiers = node.modifiers;
+      : super(null, kind, enclosing),
+        this.cachedNode = node,
+        this.modifiers = node.modifiers {
+    assert(modifiers !== null);
+  }
 
   VariableDefinitions parseNode(DiagnosticListener listener) {
     return cachedNode;
   }
 
   DartType computeType(Compiler compiler) {
     if (type != null) return type;
     compiler.withCurrentElement(this, () {
       VariableDefinitions node = parseNode(compiler);
       if (node.type !== null) {
@@ skipping 217 matching lines @@
                                 other.modifiers, enclosing,
                                 other.functionSignature);
 
   FunctionElement.tooMuchOverloading(SourceString name,
                                      FunctionExpression this.cachedNode,
                                      ElementKind kind,
                                      Modifiers this.modifiers,
                                      Element enclosing,
                                      FunctionSignature this.functionSignature)
       : super(name, kind, enclosing) {
+    assert(modifiers !== null);
     defaultImplementation = this;
   }
 
   bool get isPatched => patch !== null;
 
   /**
    * Applies a patch function to this function. The patch function's body
    * is used as replacement when parsing this function's body.
    * This method must not be called after the function has been parsed,
    * and it must be called at most once.
@@ skipping 35 matching lines @@
   FunctionType computeType(Compiler compiler) {
     if (type != null) return type;
     type = compiler.computeFunctionType(declaration,
                                         computeSignature(compiler));
     return type;
   }
 
   Node parseNode(DiagnosticListener listener) {
     if (cachedNode !== null) return cachedNode;
     if (patch === null) {
-      if (modifiers != null && modifiers.isExternal()) {
+      if (modifiers.isExternal()) {
         listener.cancel("Compiling external function with no implementation.",
                         element: this);
       }
       return null;
     }
     cachedNode = patch.parseNode(listener);
     return cachedNode;
   }
 
   Token position() => cachedNode.getBeginToken();
@@ skipping 21 matching lines @@
   }
 }
 
 class ConstructorBodyElement extends FunctionElement {
   FunctionElement constructor;
 
   ConstructorBodyElement(FunctionElement constructor)
       : this.constructor = constructor,
         super(constructor.name,
               ElementKind.GENERATIVE_CONSTRUCTOR_BODY,
-              null,
+              Modifiers.EMPTY,
               constructor.enclosingElement) {
     functionSignature = constructor.functionSignature;
   }
 
   bool isInstanceMember() => true;
 
   FunctionType computeType(Compiler compiler) {
     compiler.reportFatalError('Internal error: $this.computeType', this);
   }
 
@@ skipping 10 matching lines @@
                                  DiagnosticListener listener) {
     ConstructorBodyElement result =
       new ConstructorBodyElement(constructor.cloneTo(enclosing, listener));
     return result;
   }
 }
 
 class SynthesizedConstructorElement extends FunctionElement {
   SynthesizedConstructorElement(Element enclosing)
     : super(enclosing.name, ElementKind.GENERATIVE_CONSTRUCTOR,
-            null, enclosing);
+            Modifiers.EMPTY, enclosing);
 
   Token position() => enclosingElement.position();
 
   SynthesizedConstructorElement cloneTo(Element enclosing,
                                         DiagnosticListener listener) {
     return new SynthesizedConstructorElement(enclosing);
   }
 }
 
 class VoidElement extends Element {
@@ skipping 369 matching lines @@
            && element.isInstanceMember()
            && (element.kind === ElementKind.FIELD
                || element.kind === ElementKind.GETTER
                || element.kind === ElementKind.SETTER);
   }
 
   static bool isStaticOrTopLevel(Element element) {
     // TODO(ager): This should not be necessary when patch support has
     // been reworked.
     if (!Elements.isUnresolved(element)
-        && element.modifiers != null
         && element.modifiers.isStatic()) {
       return true;
     }
     return !Elements.isUnresolved(element)
            && !element.isInstanceMember()
            && !element.isPrefix()
            && element.enclosingElement !== null
            && (element.enclosingElement.kind == ElementKind.CLASS ||
                element.enclosingElement.kind == ElementKind.COMPILATION_UNIT ||
                element.enclosingElement.kind == ElementKind.LIBRARY);
@@ skipping 253 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }