Fixes for updating synthetic element offsets.

pkg/analyzer/lib/src/task/incremental_element_builder.dart

 // Copyright (c) 2015, 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 analyzer.src.task.incremental_element_builder;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 112 matching lines @@
 
   /**
    * Updates [oldUnit] to have the same directives and declarations, in the
    * same order as in [newUnit]. Existing resolution is kept where possible.
    *
    * Updates [unitElement] by adding/removing elements as needed.
    *
    * Fills [unitDelta] with added/remove elements.
    */
   void build() {
+    _materializeLazyElements();
     new CompilationUnitBuilder()
         .buildCompilationUnit(unitSource, newUnit, librarySource);
     _processDirectives();
     _processUnitMembers();
     _replaceUnitContents(oldUnit, newUnit);
     _findConstants();
     newUnit.element = unitElement;
     unitElement.setCodeRange(0, newUnit.endToken.end);
   }
 
@@ skipping 20 matching lines @@
     oldUnit.accept(finder);
     unitConstants.addAll(finder.constantsToCompute);
     // Update annotation constants to using the old unit element.
     for (ConstantEvaluationTarget constant in unitConstants) {
       if (constant is ElementAnnotationImpl) {
         constant.compilationUnit = unitElement;
       }
     }
   }
 
+  void _materializeLazyElements() {
+    unitElement.accept(new RecursiveElementVisitor());
+  }
+
   ClassElementDelta _processClassMembers(
       ClassDeclaration oldClass, ClassDeclaration newClass) {
     // If the class hierarchy or type parameters are changed,
     // then the class changed too much - don't compute the delta.
     if (newClass.abstractKeyword != null && oldClass.abstractKeyword == null ||
         newClass.abstractKeyword == null && oldClass.abstractKeyword != null ||
         TokenUtils.getFullCode(newClass.typeParameters) !=
             TokenUtils.getFullCode(oldClass.typeParameters) ||
         TokenUtils.getFullCode(newClass.extendsClause) !=
             TokenUtils.getFullCode(oldClass.extendsClause) ||
@@ skipping 493 matching lines @@
  */
 class _UpdateElementOffsetsVisitor extends GeneralizingElementVisitor {
   final Map<int, int> map;
 
   _UpdateElementOffsetsVisitor(this.map);
 
   void visitElement(Element element) {
     if (element is LibraryElement) {
       return;
     }
-    if (element.isSynthetic && !_isVariableInitializer(element)) {
-      return;
-    }
     if (element is ElementImpl) {
       // name offset
       {
         int oldOffset = element.nameOffset;
         int newOffset = map[oldOffset];
-        assert(newOffset != null);
+        // Some synthetic elements have new offsets, e.g. synthetic accessors
+        // of property inducing elements.  But some are purely synthetic, e.g.
+        // synthetic enum fields and their accessors.
+        if (newOffset == null) {
+          assert(element.isSynthetic);
+          return;
+        }
         element.nameOffset = newOffset;
       }
       // code range
       {
         int oldOffset = element.codeOffset;
         if (oldOffset != null) {
           int oldEnd = oldOffset + element.codeLength;
           int newOffset = map[oldOffset];
           int newEnd = map[oldEnd];
           assert(newOffset != null);
@@ skipping 21 matching lines @@
               element.setVisibleRange(newOffset, newLength);
             } else if (element is ParameterElementImpl) {
               element.setVisibleRange(newOffset, newLength);
             }
           }
         }
       }
     }
     super.visitElement(element);
   }
-
-  static bool _isVariableInitializer(Element element) {
-    return element is FunctionElement &&
-        element.enclosingElement is VariableElement;
-  }
 }