Fix an issue resolving paths when remote debugging.

editor/tools/plugins/com.google.dart.tools.debug.core/src/com/google/dart/tools/debug/core/source/UriToFileResolver.java

 /*
  * Copyright (c) 2014, 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
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
 
 package com.google.dart.tools.debug.core.source;
 
 import com.google.common.collect.Maps;
 import com.google.common.util.concurrent.Uninterruptibles;
 import com.google.dart.server.CreateContextConsumer;
 import com.google.dart.server.MapUriConsumer;
 import com.google.dart.tools.core.DartCore;
 import com.google.dart.tools.core.DartCoreDebug;
 import com.google.dart.tools.core.analysis.model.IFileInfo;
 import com.google.dart.tools.core.analysis.model.ProjectManager;
 import com.google.dart.tools.core.internal.util.ResourceUtil;
 import com.google.dart.tools.debug.core.DartLaunchConfigWrapper;
 
+import org.eclipse.core.resources.IContainer;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.debug.core.ILaunch;
 import org.eclipse.debug.core.ILaunchConfiguration;
 
 import java.io.File;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.Map;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 
 /**
  * A helper for converting URIs to files paths and vice versa.
  */
 public class UriToFileResolver {
-  private final IResource resource;
-  private final String resourcePath;
+  private IContainer container;
   private final Map<String, String> urlToFileCache = Maps.newHashMap();
   private final Map<String, String> fileToUriCache = Maps.newHashMap();
 
   private String executionContextId;
 
   public UriToFileResolver(ILaunch launch) {
     ILaunchConfiguration launchConfiguration = launch.getLaunchConfiguration();
     DartLaunchConfigWrapper wrapper = new DartLaunchConfigWrapper(launchConfiguration);
-    resource = wrapper.getApplicationResource();
-    resourcePath = resource != null ? resource.getLocation().toOSString() : null;
+
+    container = wrapper.getSourceDirectory();
+    if (container == null) {
+      IResource resource = wrapper.getApplicationResource();
+
+      if (resource instanceof IContainer) {
+        container = resource.getParent();
+      } else if (resource != null) {
+        container = resource.getParent();
+      }
+    }
+
+    String resourcePath = container != null ? container.getLocation().toOSString() : null;
+
     // create an execution context
     if (DartCoreDebug.ENABLE_ANALYSIS_SERVER && resourcePath != null) {
       DartCore.getAnalysisServer().execution_createContext(
           resourcePath,
           new CreateContextConsumer() {
             @Override
             public void computedExecutionContext(String contextId) {
               executionContextId = contextId;
             }
           });
     }
   }
 
   public void dispose() {
     // delete the execution context
     if (DartCoreDebug.ENABLE_ANALYSIS_SERVER && executionContextId != null) {
       DartCore.getAnalysisServer().execution_deleteContext(executionContextId);
       executionContextId = null;
     }
   }
 
   public String getFileForUri(String url) {
-    if (resource == null) {
+    if (container == null) {
       return null;
     }
     String file = urlToFileCache.get(url);
     if (file == null) {
       file = getFileForUri0(url);
       urlToFileCache.put(url, file);
     }
     return file;
   }
 
   public String getUriForPath(String file) {
-    if (resource == null) {
+    if (container == null) {
       return null;
     }
     String uri = fileToUriCache.get(file);
     if (uri == null) {
       uri = getUriForPath0(file);
       fileToUriCache.put(file, uri);
     }
     return uri;
   }
 
@@ skipping 39 matching lines @@
       // Handle both fully absolute path names and http: urls.
       if (url.startsWith("/")) {
         return url;
       } else if (uriScheme == null) {
         // handle relative file path
         filePath = resolveRelativePath(url);
       } else {
         filePath = uri.getPath();
       }
 
-      // dart:
       if (filePath == null) {
         return null;
       } else {
-        return filePath;
+        return returnAbsoluteOrRelative(filePath);
       }
     } catch (URISyntaxException e) {
       return null;
     }
   }
 
   /**
    * It seems that {@link ProjectManager#resolvePathToPackage} works only in limited cases. So, here
    * is a copy of another implementation.
    */
@@ skipping 55 matching lines @@
         Uninterruptibles.awaitUninterruptibly(latch, 1, TimeUnit.SECONDS);
         return uriPtr[0];
       }
     } else {
       {
         String uri = getUriForPath_fromServerBreakpointManager(file);
         if (uri != null) {
           return uri;
         }
       }
-      return DartCore.getProjectManager().resolvePathToPackage(resource, file);
+      return DartCore.getProjectManager().resolvePathToPackage(container, file);
     }
     return null;
   }
 
   private String resolvePackageUri(String url) {
     if (DartCoreDebug.ENABLE_ANALYSIS_SERVER) {
       if (executionContextId != null) {
         final String[] filePtr = {null};
         final CountDownLatch latch = new CountDownLatch(1);
         DartCore.getAnalysisServer().execution_mapUri(
             executionContextId,
             null,
             url,
             new MapUriConsumer() {
               @Override
               public void computedFileOrUri(String file, String uri) {
                 filePtr[0] = file;
                 latch.countDown();
               }
             });
         Uninterruptibles.awaitUninterruptibly(latch, 1, TimeUnit.SECONDS);
         return filePtr[0];
       }
     } else {
       ProjectManager projectManager = DartCore.getProjectManager();
-      IFileInfo fileInfo = projectManager.resolveUriToFileInfo(resource, url);
+      IFileInfo fileInfo = projectManager.resolveUriToFileInfo(container, url);
       if (fileInfo != null) {
         File file = fileInfo.getFile();
         File absoluteFile = file.getAbsoluteFile();
         return absoluteFile.toURI().toString();
       }
     }
     return null;
   }
 
   private String resolveRelativePath(String url) {
-    if (resource != null) {
-      IResource file = resource.getParent().findMember(url);
+    if (container != null) {
+      IResource file = container.getParent().findMember(url);
       if (file != null) {
         return file.getLocation().toOSString();
       }
     }
     return null;
   }
+
+  private String returnAbsoluteOrRelative(String path) {
+    // If path exists, return that.
+    File file = new File(path);
+    if (file.exists()) {
+      return path;
+    }
+
+    // Try and return a path relative to the resource.
+    if (container != null) {
+      int index = path.indexOf('/');
+
+      while (index != -1) {
+        String subPath = path.substring(index + 1);
+        IResource resource = container.findMember(subPath);
+        if (resource != null) {
+          return resource.getLocation().toFile().getAbsolutePath();
+        }
+        index = path.indexOf('/', index + 1);
+      }
+    }
+
+    // Else, return the original path.
+    return path;
+  }
 }