Version 0.8.10.4

dart/editor/tools/plugins/com.google.dart.tools.ui/src/com/google/dart/tools/ui/internal/text/dart/DartReconcilingStrategy.java

 /*
  * Copyright (c) 2012, the Dart project authors.
  * 
  * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
  * in compliance with the License. You may obtain a copy of the License at
  * 
  * http://www.eclipse.org/legal/epl-v10.html
  * 
  * Unless required by applicable law or agreed to in writing, software distributed under the License
  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
@@ skipping 64 matching lines @@
    * not be {@code null}.
    */
   private IDocument document;
 
   /**
    * Synchronize against this field before accessing {@link #dirtyRegion}
    */
   private final Object lock = new Object();
 
   /**
-   * The region of source that has changed, which may be empty. Synchronize against {@link #lock}
-   * before accessing this field.
+   * The region of source that has changed and needs to be reconciled, or empty if analysis of this
+   * file is up to date, or {@code null} if the entire file needs to be reconciled. Synchronize
+   * against {@link #lock} before accessing this field.
    */
   private DartReconcilingRegion dirtyRegion = DartReconcilingRegion.EMPTY;
 
   /**
    * Listen for analysis results for the source being edited and update the editor.
    */
   private final AnalysisListener analysisListener = new AnalysisListener() {
 
     @Override
     public void complete(AnalysisEvent event) {
@@ skipping 21 matching lines @@
     public void documentAboutToBeChanged(DocumentEvent event) {
     }
 
     @Override
     public void documentChanged(DocumentEvent event) {
 
       // Record the source region that has changed
       String newText = event.getText();
       int newLength = newText != null ? newText.length() : 0;
       synchronized (lock) {
-        dirtyRegion = dirtyRegion.add(event.getOffset(), event.getLength(), newLength);
+        if (dirtyRegion != null) {
+          dirtyRegion = dirtyRegion.add(event.getOffset(), event.getLength(), newLength);
+        }
       }
       editor.applyResolvedUnit(null);
 
       // Start analysis immediately if "." pressed to improve code completion response
-      if (".".equals(newText)) {
+      if (".".endsWith(newText)) {
         reconcile();
       }
     }
   };
 
   /**
    * Construct a new instance for the specified editor.
    * 
    * @param editor the editor (not {@code null})
    */
@@ skipping 69 matching lines @@
     }
   }
 
   /**
    * Activates reconciling of the current dirty region.
    */
   public void reconcile() {
     InstrumentationBuilder instrumentation = Instrumentation.builder("DartReconcilingStrategy-reconcile");
     try {
       instrumentation.data("Name", editor.getTitle());
-      DartReconcilingRegion r;
+      DartReconcilingRegion region;
       synchronized (lock) {
-        if (dirtyRegion.isEmpty()) {
-          return;
-        }
-        r = dirtyRegion;
+        region = dirtyRegion;
         dirtyRegion = DartReconcilingRegion.EMPTY;
       }
-      instrumentation.data("Offset", r.getOffset());
-      instrumentation.data("OldLength", r.getOldLength());
-      instrumentation.data("NewLength", r.getNewLength());
-      sourceChanged(document.get(), r.getOffset(), r.getOldLength(), r.getNewLength());
-      performAnalysisInBackground();
+      if (region == null) {
+        String code = document.get();
+        instrumentation.data("Length", code.length());
+        sourceChanged(code);
+        performAnalysisInBackground();
+      } else if (!region.isEmpty()) {
+        instrumentation.data("Offset", region.getOffset());
+        instrumentation.data("OldLength", region.getOldLength());
+        instrumentation.data("NewLength", region.getNewLength());
+        sourceChanged(
+            document.get(),
+            region.getOffset(),
+            region.getOldLength(),
+            region.getNewLength());
+        performAnalysisInBackground();
+      }
     } finally {
       instrumentation.log();
     }
   }
 
   @Override
   public void reconcile(DirtyRegion dirtyRegion, IRegion subRegion) {
     reconcile();
   }
 
@@ skipping 92 matching lines @@
   }
 
   /**
    * Apply analysis results only if there are no pending source changes.
    */
   private void applyAnalysisResult(CompilationUnit unit) {
     if (unit == null) {
       return;
     }
     synchronized (lock) {
-      if (!dirtyRegion.isEmpty()) {
+      if (dirtyRegion == null || !dirtyRegion.isEmpty()) {
         return;
       }
     }
     editor.applyResolvedUnit(unit);
   }
 
   /**
    * Get the resolved compilation unit from the editor's analysis context and apply that unit.
    * 
    * @return {@code true} if a resolved unit was obtained and applied
@@ skipping 51 matching lines @@
    * @param newLength the number of characters in the replacement text
    */
   private void sourceChanged(String code, int offset, int oldLength, int newLength) {
     AnalysisContext context = editor.getInputAnalysisContext();
     Source source = editor.getInputSource();
     if (context != null && source != null) {
       context.setChangedContents(source, code, offset, oldLength, newLength);
     }
   }
 }