Insert checks before deferred calls and accesses.

sdk/lib/_internal/compiler/implementation/elements/modelx.dart

 // Copyright (c) 2013, 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.modelx;
 
 import 'elements.dart';
 import '../tree/tree.dart';
 import '../util/util.dart';
 import '../resolution/resolution.dart';
@@ skipping 313 matching lines @@
 class ErroneousElementX extends ElementX implements ErroneousElement {
   final MessageKind messageKind;
   final Map messageArguments;
 
   ErroneousElementX(this.messageKind, this.messageArguments,
                     String name, Element enclosing)
       : super(name, ElementKind.ERROR, enclosing);
 
   isErroneous() => true;
 
+  AbstractFieldElement abstractField;
+
   unsupported() {
     throw 'unsupported operation on erroneous element';
   }
 
   Link<MetadataAnnotation> get metadata => unsupported();
   get node => unsupported();
   get type => unsupported();
   get cachedNode => unsupported();
   get functionSignature => unsupported();
   get patch => null;
@@ skipping 189 matching lines @@
    * and a setter.
    *
    * The abstract field is added once, for the first getter or setter, and
    * reused if the other one is also added.
    * The abstract field should not be treated as a proper member of the
    * container, it's simply a way to return two results for one lookup.
    * That is, the getter or setter does not have the abstract field as enclosing
    * element, they are enclosed by the class or compilation unit, as is the
    * abstract field.
    */
-  void addAccessor(Element accessor,
+  void addAccessor(FunctionElementX accessor,
                    Element existing,
                    DiagnosticListener listener) {
     void reportError(Element other) {
       listener.reportError(accessor,
                            MessageKind.DUPLICATE_DEFINITION,
                            {'name': accessor.name});
       // TODO(johnniwinther): Make this an info instead of a fatal error.
       listener.reportFatalError(other,
                                 MessageKind.EXISTING_DEFINITION,
                                 {'name': accessor.name});
     }
 
     if (existing != null) {
       if (!identical(existing.kind, ElementKind.ABSTRACT_FIELD)) {
         reportError(existing);
       } else {
         AbstractFieldElementX field = existing;
+        accessor.abstractField = field;
         if (accessor.isGetter()) {
           if (field.getter != null && field.getter != accessor) {
             reportError(field.getter);
           }
           field.getter = accessor;
         } else {
           assert(accessor.isSetter());
           if (field.setter != null && field.setter != accessor) {
             reportError(field.setter);
           }
           field.setter = accessor;
         }
       }
     } else {
       Element container = accessor.getEnclosingClassOrCompilationUnit();
       AbstractFieldElementX field =
           new AbstractFieldElementX(accessor.name, container);
+      accessor.abstractField = field;
       if (accessor.isGetter()) {
         field.getter = accessor;
       } else {
         field.setter = accessor;
       }
       add(field, listener);
     }
   }
 }
 
@@ skipping 904 matching lines @@
   /**
    * A function declaration that should be parsed instead of the current one.
    * The patch should be parsed as if it was in the current scope. Its
    * signature must match this function's signature.
    */
   FunctionElement patch = null;
   FunctionElement origin = null;
 
   final bool _hasNoBody;
 
+  AbstractFieldElement abstractField;
+
   /**
    * If this is a redirecting factory, [defaultImplementation] will be
    * changed by the resolver to point to the redirection target.
    * Otherwise, [:identical(defaultImplementation, this):].
    */
   // TODO(ahe): Rename this field to redirectionTarget.
   FunctionElement defaultImplementation;
 
   FunctionElementX(String name,
                    ElementKind kind,
@@ skipping 1106 matching lines @@
 
   ParameterMetadataAnnotation(Metadata this.metadata);
 
   Node parseNode(DiagnosticListener listener) => metadata.expression;
 
   Token get beginToken => metadata.getBeginToken();
 
   Token get endToken => metadata.getEndToken();
 }