Disaply compile error position in diff viewer

plugins/org.chromium.debug.ui/src/org/chromium/debug/ui/liveedit/PushResultParser.java

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.debug.ui.liveedit;
 
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 
 import org.chromium.debug.core.model.PushChangesPlan;
 import org.chromium.debug.core.model.SourceWrapSupport;
 import org.chromium.debug.ui.liveedit.LiveEditDiffViewer.FunctionNode;
 import org.chromium.debug.ui.liveedit.LiveEditDiffViewer.Side;
 import org.chromium.debug.ui.liveedit.LiveEditDiffViewer.SourcePosition;
 import org.chromium.debug.ui.liveedit.LiveEditDiffViewer.SourceText;
 import org.chromium.sdk.UpdatableScript;
 import org.chromium.sdk.UpdatableScript.NewFunctionNode;
@@ skipping 40 matching lines @@
       newSource = newSourceComment + wrapperMatch.wrap(newSourceRaw);
       newPositionOffset = newSourceComment.length();
       textualDiff = shiftNewPositions(changeDescription.getTextualDiff(),
           oldSourceComment.length(), newSourceComment.length(), wrapperMatch.getPrefixLength(),
           wrapperMatch.getSuffixLength(), oldSourceRaw.length(), newSourceRaw.length());
     }
 
     TreeBuilder builder = new TreeBuilder(previewMode, oldPositionOffset, newPositionOffset);
     final FunctionNode rootFunction = builder.build(changeDescription);
 
-    return new LiveEditDiffViewer.Input() {
-      public SourceText getNewSource() {
-        return new SourceText() {
-          public String getText() {
-            return newSource;
-          }
-          public String getTitle() {
-            return Messages.PushResultParser_LOCAL_FILE;
-          }
-        };
-      }
-      public SourceText getOldSource() {
-        return new SourceText() {
-          public String getText() {
-            return oldSource;
-          }
-          public String getTitle() {
-            return Messages.PushResultParser_SCRIPT_IN_VM;
-          }
-        };
-      }
-
-      public FunctionNode getRootFunction() {
+    return new InputBase(newSource, oldSource) {
+      @Override public FunctionNode getRootFunction() {
         return rootFunction;
       }
-
-      @Override
-      public TextualDiff getTextualDiff() {
+      @Override public TextualDiff getTextualDiff() {
         return textualDiff;
       }
     };
   }
+
+  static LiveEditDiffViewer.Input createCompileErrorViewerInput(
+      final UpdatableScript.CompileErrorFailure compileError, PushChangesPlan changesPlan,
+      boolean previewMode) {
+
+    final String newSource = changesPlan.getNewSource();
+    final String oldSource = changesPlan.getScript().getSource();
+
+    final int startOffset = compileError.getStartPosition().getOffset();
+    final int endOffset;
+    if (compileError.getEndPosition() == null) {
+      endOffset = startOffset + 1;
+    } else {
+      endOffset = compileError.getEndPosition().getOffset();
+    }
+    final SourcePosition sourcePosition = new SourcePosition() {
+      @Override public int getStart() {
+        return startOffset;
+      }
+      @Override public int getEnd() {
+        return endOffset;
+      }
+    };
+
+    final TextualDiff fakeTextualDiff = new TextualDiff() {
+      @Override
+      public List<Long> getChunks() {
+        return Arrays.asList(
+            0L, (long) oldSource.length(), (long) newSource.length());
+      }
+    };
+
+    final FunctionNode fakeFunctionNode = new FunctionNode() {
+      @Override public String getName() {
+        return compileError.getCompilerMessage();
+      }
+      @Override public String getStatus() {
+        return Messages.PushResultParser_COMPILE_ERROR;
+      }
+      @Override public List<? extends FunctionNode> children() {
+        return Collections.emptyList();
+      }
+      @Override public SourcePosition getPosition(Side side) {
+        switch (side) {
+        case NEW:
+          return sourcePosition;
+        default:
+          return null;
+        }
+      }
+      @Override public FunctionNode getParent() {
+        return null;
+      }
+    };
+
+    return new InputBase(newSource, oldSource) {
+      @Override public FunctionNode getRootFunction() {
+        return fakeFunctionNode;
+      }
+      @Override public TextualDiff getTextualDiff() {
+        return fakeTextualDiff;
+      }
+    };
+  }
 
   private static class TreeBuilder {
     private final StatusRenderer statusRenderer;
     private final boolean hideOldVersion;
     private final int oldPositionOffset;
     private final int newPositionOffset;
 
     public TreeBuilder(boolean previewOnly, int oldPositionOffset, int newPositionOffset) {
       if (previewOnly) {
         this.statusRenderer = PREVIEW_STATUS_RENDERER;
       } else {
         this.statusRenderer = RESULT_STATUS_RENDERER;
       }
       this.hideOldVersion = !previewOnly;
       this.oldPositionOffset = oldPositionOffset;
       this.newPositionOffset = newPositionOffset;
     }
 
     public FunctionNode build(UpdatableScript.ChangeDescription changeDescription) {
-      return buildNode(changeDescription.getChangeTree());
+      return buildNode(changeDescription.getChangeTree(), Messages.PushResultParser_SCRIPT);
     }
 
-    private NodeImpl buildNode(UpdatableScript.OldFunctionNode oldFunction) {
+    private NodeImpl buildNode(UpdatableScript.OldFunctionNode oldFunction,
+        String predefinedFunctionName) {
       List<NodeImpl> childListFirst = new ArrayList<NodeImpl>();
       for (UpdatableScript.OldFunctionNode oldChild : oldFunction.children()) {
-        NodeImpl nodeImpl = buildNode(oldChild);
+        NodeImpl nodeImpl = buildNode(oldChild, null);
         childListFirst.add(nodeImpl);
       }
       List<NodeImpl> childListSecond = new ArrayList<NodeImpl>();
       for (NewFunctionNode newChild : oldFunction.newChildren()) {
         NodeImpl nodeImpl = buildNode(newChild, newPositionOffset);
         childListSecond.add(nodeImpl);
       }
       // Merge lists by positions SIDE.NEW
       List<NodeImpl> childList = new ArrayList<NodeImpl>();
       {
@@ skipping 19 matching lines @@
               pos1++;
             } else {
               childList.add(childListSecond.get(pos2));
               pos2++;
             }
           }
         }
       }
       return new NodeImpl(oldFunction,
           createPosition(oldFunction.getPositions(), oldPositionOffset),
-          createPosition(oldFunction.getNewPositions(), newPositionOffset), childList);
+          createPosition(oldFunction.getNewPositions(), newPositionOffset), childList,
+          predefinedFunctionName);
     }
     private NodeImpl buildNode(UpdatableScript.NewFunctionNode newFunction,
         int newPositionOffset) {
       List<NodeImpl> childList = new ArrayList<NodeImpl>();
       for (UpdatableScript.NewFunctionNode newChild : newFunction.children()) {
         NodeImpl nodeImpl = buildNode(newChild, newPositionOffset);
         childList.add(nodeImpl);
       }
       return new NodeImpl(newFunction, null,
-          createPosition(newFunction.getPositions(), newPositionOffset), childList);
+          createPosition(newFunction.getPositions(), newPositionOffset), childList, null);
     }
 
     private static SourcePosition createPosition(
         final UpdatableScript.FunctionPositions positions, final int offset) {
       if (positions == null) {
         return null;
       }
       return new SourcePosition() {
         public int getStart() {
           return (int) positions.getStart() + offset;
         }
         public int getEnd() {
           return (int) positions.getEnd() + offset;
         }
       };
     }
 
     private class NodeImpl implements FunctionNode {
       private final UpdatableScript.FunctionNode<?> rawFunction;
       private final String name;
       private final SourcePosition oldPosition;
       private final SourcePosition newPosition;
       private final List<? extends FunctionNode> childList;
       private FunctionNode parent = null;
 
       private NodeImpl(UpdatableScript.FunctionNode<?> rawFunction, SourcePosition oldPosition,
-          SourcePosition newPosition, List<? extends NodeImpl> childList) {
+          SourcePosition newPosition, List<? extends NodeImpl> childList,
+          String predefinedFunctionName) {
         this.rawFunction = rawFunction;
-        this.name = rawFunction.getName();
+        if (predefinedFunctionName == null) {
+          this.name = rawFunction.getName();
+        } else {
+          this.name = predefinedFunctionName;
+        }
         this.oldPosition = oldPosition;
         this.newPosition = newPosition;
         this.childList = childList;
         for (NodeImpl child : childList) {
           child.parent = this;
         }
       }
       public List<? extends FunctionNode> children() {
         return childList;
       }
@@ skipping 118 matching lines @@
     shiftedChunks.add((long) originalOldLength + oldCommentLength);
     shiftedChunks.add((long) originalNewLength + newCommentLength + prefixLength + suffixLength);
 
     return new TextualDiff() {
       @Override
       public List<Long> getChunks() {
         return shiftedChunks;
       }
     };
   }
+
+  private static abstract class InputBase implements LiveEditDiffViewer.Input {
+    private final String newSource;
+    private final String oldSource;
+
+    InputBase(String newSource, String oldSource) {
+      this.newSource = newSource;
+      this.oldSource = oldSource;
+    }
+
+    public SourceText getNewSource() {
+      return new SourceText() {
+        public String getText() {
+          return newSource;
+        }
+        public String getTitle() {
+          return Messages.PushResultParser_LOCAL_FILE;
+        }
+      };
+    }
+    public SourceText getOldSource() {
+      return new SourceText() {
+        public String getText() {
+          return oldSource;
+        }
+        public String getTitle() {
+          return Messages.PushResultParser_SCRIPT_IN_VM;
+        }
+      };
+    }
+  }
 }