Disaply compile error position in diff viewer

plugins/org.chromium.debug.ui/src/org/chromium/debug/ui/liveedit/WizardLogicBuilder.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 static org.chromium.debug.ui.DialogUtils.createConstant;
 import static org.chromium.debug.ui.DialogUtils.createErrorOptional;
 import static org.chromium.debug.ui.DialogUtils.createOptional;
 import static org.chromium.debug.ui.DialogUtils.createProcessor;
@@ skipping 23 matching lines @@
 import org.chromium.debug.ui.DialogUtils.ValueSource;
 import org.chromium.debug.ui.WizardUtils.LogicBasedWizard;
 import org.chromium.debug.ui.WizardUtils.NextPageEnabler;
 import org.chromium.debug.ui.WizardUtils.PageElements;
 import org.chromium.debug.ui.WizardUtils.PageImpl;
 import org.chromium.debug.ui.WizardUtils.PageListener;
 import org.chromium.debug.ui.WizardUtils.WizardFinishController;
 import org.chromium.debug.ui.WizardUtils.WizardFinisher;
 import org.chromium.debug.ui.WizardUtils.WizardLogic;
 import org.chromium.debug.ui.actions.ChooseVmControl;
+import org.chromium.debug.ui.liveedit.LiveEditDiffViewer.Input;
 import org.chromium.debug.ui.liveedit.PushChangesWizard.FinisherDelegate;
+import org.chromium.sdk.TextStreamPosition;
 import org.chromium.sdk.UpdatableScript.ChangeDescription;
+import org.chromium.sdk.UpdatableScript.CompileErrorFailure;
+import org.eclipse.osgi.util.NLS;
 
 /**
  * Creates Updater-based logic implementation of the wizard. It is responsible for proper data
  * manipulation and view control updates.
  * <p>
  * The wizard pages are arranged in graph with one fork:<br>
  * 'choose vm' -&gt;
  * <ul>
  * <li>[single vm path] -&gt; 'textual preview' -&gt; 'v8 preview'
  * <li>[multiple vm path] -&gt; 'multiple vm stub'
@@ skipping 53 matching lines @@
         List<Optional<PushChangesPlan>> result =
             new ArrayList<DialogUtils.Optional<PushChangesPlan>>(input.size());
         for (ScriptTargetMapping mapping : input) {
           Optional<PushChangesPlan> optionalPlan;
           try {
             PushChangesPlan plan = PushChangesPlan.create(mapping);
             optionalPlan = createOptional(plan);
           } catch (RuntimeException e) {
             // TODO: have more specific exception types to catch.
             optionalPlan = createErrorOptional(new Message(
-                "Failed to get script source from a file. See log for details.",
+                Messages.WizardLogicBuilder_FAILED_TO_GET,
                 MessagePriority.BLOCKING_PROBLEM));
           }
           result.add(optionalPlan);
         }
         return result;
       }
     });
     updater.addSource(scope, selectedChangePlansValue);
     updater.addConsumer(scope, selectedChangePlansValue);
     updater.addDependency(selectedChangePlansValue, selectedVmInput);
 
 
     // A derived value of selected VMs list; the list is non-empty or the value is error.
     final ValueProcessor<? extends Optional<List<PushChangesPlan>>> nonEmptySelectedPlansValue =
         createProcessor(new Gettable<Optional<List<PushChangesPlan>>>() {
       public Optional<List<PushChangesPlan>> getValue() {
         List<Optional<PushChangesPlan>> planList = selectedChangePlansValue.getValue();
         if (planList.isEmpty()) {
           return createErrorOptional(
-              new Message("Choose at least one VM", MessagePriority.BLOCKING_INFO));
+              new Message(Messages.WizardLogicBuilder_CHOOSE_VM, MessagePriority.BLOCKING_INFO));
         }
         List<Message> errorMessages = new LinkedList<Message>();
         List<PushChangesPlan> result = new ArrayList<PushChangesPlan>(planList.size());
         for (Optional<PushChangesPlan> optionalPlan : planList) {
           if (optionalPlan.isNormal()) {
             result.add(optionalPlan.getNormal());
           } else {
             errorMessages.addAll(optionalPlan.errorMessages());
           }
         }
@@ skipping 126 matching lines @@
     });
 
     // Parses raw preview value and converts it into a form suitable for the viewer; also handles
     // errors that become warnings.
     final ValueProcessor<Optional<? extends LiveEditDiffViewer.Input>> previewValue =
       createProcessor(handleErrors(
           new NormalExpression<LiveEditDiffViewer.Input>() {
             @Calculate
             public Optional<? extends LiveEditDiffViewer.Input> calculate(
                 PreviewLoader.Data previewRawResultParam) {
-              PushChangesPlan changesPlan = singlePlanValue.getValue();
-              ChangeDescription changeDescription = previewRawResultParam.getChangeDescription();
-              Optional<LiveEditDiffViewer.Input> result;
-              if (changeDescription == null) {
-                result = createOptional(null);
-              } else {
-                try {
+              final PushChangesPlan changesPlan = singlePlanValue.getValue();
+
+              return previewRawResultParam.accept(
+                  new PreviewLoader.Data.Visitor<Optional<LiveEditDiffViewer.Input>>() {
+                @Override
+                public Optional<LiveEditDiffViewer.Input> visitSuccess(
+                    ChangeDescription changeDescription) {
+                  if (changeDescription == null) {
+                    return createOptional(null);
+                  } else {
+                    try {
+                      LiveEditDiffViewer.Input viewerInput =
+                          PushResultParser.createViewerInput(changeDescription, changesPlan, true);
+                      return createOptional(viewerInput);
+                    } catch (RuntimeException e) {
+                      ChromiumDebugPlugin.log(e);
+                      String messageText =
+                          NLS.bind(Messages.WizardLogicBuilder_ERROR_GETTING_PREVIEW, e.toString());
+                      return createErrorOptional(
+                          new Message(messageText, MessagePriority.WARNING));
+                    }
+                  }
+                }
+
+                @Override
+                public Optional<Input> visitCompileError(CompileErrorFailure compileError) {
                   LiveEditDiffViewer.Input viewerInput =
-                      PushResultParser.createViewerInput(changeDescription, changesPlan, true);
-                  result = createOptional(viewerInput);
-                } catch (RuntimeException e) {
-                  ChromiumDebugPlugin.log(e);
-                  result = createErrorOptional(new Message(
-                      "Error in getting preview: " + e.toString(), MessagePriority.WARNING));
+                      PushResultParser.createCompileErrorViewerInput(compileError, changesPlan,
+                          true);
+                  return createOptional(viewerInput);
                 }
-              }
-              return result;
+              });
             }
             @DependencyGetter
             public ValueSource<Optional<PreviewLoader.Data>>
                 previewRawResultValueSource() {
               return previewRawResultValue;
             }
           }));
 
 
 
@@ skipping 15 matching lines @@
         v8PreviewPage.getPageElements().getPreviewViewer().setInput(viewerInput);
       }
     };
     updater.addConsumer(scope, v8PreviewInputSetter);
     updater.addDependency(v8PreviewInputSetter, previewValue);
 
     // A warning generator that collects them from v8 preview loader.
     final ValueProcessor<Optional<Void>> warningValue = createProcessor(
         new Gettable<Optional<Void>>() {
       public Optional<Void> getValue() {
-        Optional<?> previewResult = previewValue.getValue();
+        Optional<PreviewLoader.Data> previewResult = previewRawResultValue.getValue();
         if (previewResult.isNormal()) {
-          return createOptional(null);
+          PreviewLoader.Data data = previewResult.getNormal();
+          return data.accept(new PreviewLoader.Data.Visitor<Optional<Void>>() {
+            @Override public Optional<Void> visitSuccess(ChangeDescription changeDescription) {
+              return createOptional(null);
+            }
+            @Override
+            public Optional<Void> visitCompileError(CompileErrorFailure compileError) {
+              TextStreamPosition start = compileError.getStartPosition();
+              String messageString = NLS.bind(Messages.WizardLogicBuilder_COMPILE_ERROR_AT,
+                  new Object[] { compileError.getCompilerMessage(),
+                  start.getLine(), start.getColumn() });
+              return createErrorOptional(
+                  new Message(messageString, MessagePriority.BLOCKING_PROBLEM));
+            }
+          });
         } else {
           return createErrorOptional(previewResult.errorMessages());
         }
       }
     });
     updater.addConsumer(scope, warningValue);
     updater.addSource(scope, warningValue);
-    updater.addDependency(warningValue, previewValue);
+    updater.addDependency(warningValue, previewRawResultValue);
 
     // A finisher delegate source, that does not actually depend on most of the code above.
     final ValueProcessor<? extends Optional<FinisherDelegate>> wizardFinisher =
         createProcessor((
             new Gettable<Optional<FinisherDelegate>>() {
           public Optional<FinisherDelegate> getValue() {
             FinisherDelegate finisher =
                 new PushChangesWizard.SingleVmFinisher(singlePlanValue.getValue());
             return createOptional(finisher);
           }
@@ skipping 26 matching lines @@
 
     ScopeEnabler scopeEnabler =
         new NextPageEnabler(basePage, multipleVmStubPage);
 
     Scope scope = switcher.addScope(Boolean.FALSE, scopeEnabler);
 
     final ValueProcessor<Optional<? extends FinisherDelegate>> wizardFinisher =
         createProcessor(handleErrors(new NormalExpression<FinisherDelegate>() {
           @Calculate
           public FinisherDelegate calculate(List<PushChangesPlan> selectedVm) {
-            return new PushChangesWizard.MultipleVmFinisher(selectedVmValue.getValue().getNormal());
+            return new PushChangesWizard.MultipleVmFinisher(
+                selectedVmValue.getValue().getNormal());
           }
           @DependencyGetter
           public ValueSource<? extends Optional<? extends List<PushChangesPlan>>>
               getSelectVmSource() {
             return selectedVmValue;
           }
         }));
     updater.addSource(scope, wizardFinisher);
     updater.addConsumer(scope, wizardFinisher);
     updater.addDependency(wizardFinisher, selectedVmValue);
 
     final ValueSource<Optional<Void>> warningValue =
         createConstant(createOptional((Void) null), updater);
 
     return new PreviewAndOptionPath() {
       public ValueSource<? extends Optional<? extends FinisherDelegate>>
           getFinisherDelegateValue() {
         return wizardFinisher;
       }
       public ValueSource<Optional<Void>> getWarningValue() {
         return warningValue;
       }
     };
   }
 }