Fix for cascade sections SourceInfo

compiler/javatests/com/google/dart/compiler/CompilerTestCase.java

 // 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.
 
 package com.google.dart.compiler;
 
 import static com.google.dart.compiler.common.ErrorExpectation.assertErrors;
 
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
@@ skipping 16 matching lines @@
 
 import junit.framework.TestCase;
 
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.Reader;
 import java.net.URI;
 import java.net.URL;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
 
 /**
  * Base class for compiler tests, with helpful utility methods.
  */
 public abstract class CompilerTestCase extends TestCase {
 
   private static final String UTF8 = "UTF-8";
   protected CompilerConfiguration compilerConfiguration;
   protected String testSource;
   protected DartUnit testUnit;
@@ skipping 216 matching lines @@
     // be overriden to do extra checks.
     URL url = inputUrlFor(getClass(), path);
     String source = readUrl(url);
     return parseUnit(path, source);
   }
 
   /**
    * Parse a single compilation unit for the name and source.
    */
   protected DartUnit parseUnit(String srcName, String sourceCode, Object... errors) {
+    testSource = sourceCode;
     // TODO(jgw): We'll need to fill in the library parameter when testing multiple units.
     DartSourceTest src = new DartSourceTest(srcName, sourceCode, null);
     DartCompilerListenerTest listener = new DartCompilerListenerTest(srcName, errors);
-    DartUnit unit = makeParser(src, sourceCode, listener).parseUnit();
+    testUnit = makeParser(src, sourceCode, listener).parseUnit();
     listener.checkAllErrorsReported();
-    return unit;
+    return testUnit;
   }
 
   /**
    * Parse a single compilation unit for the name and source. The parse expects some kind of error,
    * but isn't picky about the actual contents. This is useful for testing parser recovery where we
    * don't want to make the test too brittle.
    */
   protected DartUnit parseUnitUnspecifiedErrors(String srcName, String sourceCode) {
     DartSourceTest src = new DartSourceTest(srcName, sourceCode, null);
     final List<DartCompilationError> errorsEncountered = Lists.newArrayList();
@@ skipping 86 matching lines @@
   }
 
   /**
    * Parses given source and checks parsing problems.
    */
   protected final void parseExpectWarnings(String code, ErrorExpectation... expectedWarnings) {
     DartParserRunner runner =  DartParserRunner.parse(getName(), code, Integer.MAX_VALUE, true);
     List<DartCompilationError> errors = runner.getErrors();
     assertErrors(errors, expectedWarnings);
   }
+  
   /**
-   * @return the {@link DartExpression} with given source. This is inaccurate approach, but good
+   * Find node in {@link #testUnit} parsed form {@link #testSource}.
+   */
+  public <T extends DartNode> T findNode(final Class<T> clazz, String pattern) {
+    final int index = testSource.indexOf(pattern);
+    assertTrue(index != -1);
+    final AtomicReference<T> result = new AtomicReference<T>();
+    testUnit.accept(new ASTVisitor<Void>() {
+      @Override
+      @SuppressWarnings("unchecked")
+      public Void visitNode(DartNode node) {
+        SourceInfo sourceInfo = node.getSourceInfo();
+        if (sourceInfo.getOffset() <= index
+            && index < sourceInfo.getEnd()
+            && clazz.isInstance(node)) {
+          result.set((T) node);
+        }
+        return super.visitNode(node);
+      }
+    });
+    return result.get();
+  }
+
+  /**
+   * @return the {@link DartExpression} with given {@link DartNode#toSource()}. This is inaccurate approach, but good
    *         enough for specific tests.
    */
   @SuppressWarnings("unchecked")
-  protected static <T extends DartExpression> T findExpression(DartNode rootNode, final String sampleSource) {
-    final DartExpression result[] = new DartExpression[1];
+  protected static <T extends DartNode> T findNodeBySource(DartNode rootNode, final String sampleSource) {
+    final DartNode result[] = new DartNode[1];
     rootNode.accept(new ASTVisitor<Void>() {
       @Override
-      public Void visitExpression(DartExpression node) {
+      public Void visitNode(DartNode node) {
         if (node.toSource().equals(sampleSource)) {
           result[0] = node;
         }
-        return super.visitExpression(node);
+        return super.visitNode(node);
       }
     });
     return (T) result[0];
   }
 
   protected static DartFunctionTypeAlias findTypedef(DartNode rootNode, final String name) {
     final DartFunctionTypeAlias result[] = new DartFunctionTypeAlias[1];
     rootNode.accept(new ASTVisitor<Void>() {
       @Override
       public Void visitFunctionTypeAlias(DartFunctionTypeAlias node) {
         if (node.getName().getName().equals(name)) {
           result[0] = node;
         }
         return null;
       }
     });
     return result[0];
   }
 
   public static String getNodeSource(String code, DartNode node) {
     SourceInfo sourceInfo = node.getSourceInfo();
     return code.substring(sourceInfo.getOffset(), sourceInfo.getEnd());
   }
 
+  /**
+   * Asserts that parsed {@link DartUnit} has {@link DartExpression} with given source and its
+   * {@link SourceInfo} points to the given source.
+   */
+  protected void assertNodeSourceInfo(String nodeSource) {
+    DartNode node = findNode(DartNode.class, nodeSource);
+    assertNotNull(node);
+    SourceInfo sourceInfo = node.getSourceInfo();
+    String actualSource = testSource.substring(sourceInfo.getOffset(), sourceInfo.getEnd());
+    assertEquals(nodeSource, actualSource);
+  }
+
 
   /**
    * Asserts that {@link Element} with given name has expected type.
    */
   protected static void assertInferredElementTypeString(
       DartUnit unit,
       String variableName,
       String expectedType) {
     // find element
     Element element = getNamedElement(unit, variableName);
@@ skipping 25 matching lines @@
         Element element = node.getElement();
         if (element != null && element.getName().equals(name)) {
           result[0] = element;
         }
         return super.visitIdentifier(node);
       }
     });
     return result[0];
   }
 }