Add a URL with typed schemes

Summary:
We're going to be adding support for a "starlark:" uri scheme for native types. Previously all code erroneously assumed a file:// scheme.

Add this type so that all supported cases are covered by the LSPContext trait and clients can make sure they cover everything that the LSP client might require.

Reviewed By: ndmitchell

Differential Revision: D38307726

fbshipit-source-id: d3195491c0111a9f6905ef3c444869097283f2f4

Author: Natalie Jameson

starlark/bin/eval.rs

@@ -33,6 +33,7 @@ use starlark::eval::Evaluator;
 use starlark::lsp::server::LoadContentsError;
 use starlark::lsp::server::LspContext;
 use starlark::lsp::server::LspEvalResult;
+use starlark::lsp::server::LspUrl;
 use starlark::lsp::server::ResolveLoadError;
 use starlark::lsp::server::StringLiteralResult;
 use starlark::syntax::AstModule;
@@ -126,7 +127,7 @@ impl Context {
     ) -> EvalResult<impl Iterator<Item = EvalMessage>> {
         match result {
             Err(e) => EvalResult {
-                messages: Either::Left(iter::once(EvalMessage::from_anyhow(file, &e))),
+                messages: Either::Left(iter::once(EvalMessage::from_anyhow(Path::new(file), &e))),
                 ast: None,
             },
             Ok(res) => EvalResult {
@@ -210,29 +211,42 @@ impl Context {
 }
 
 impl LspContext for Context {
-    fn parse_file_with_contents(&self, uri: &Url, content: String) -> LspEvalResult {
-        let EvalResult { messages, ast } = self.file_with_contents(uri.path(), content);
-        LspEvalResult {
-            diagnostics: messages.map(Diagnostic::from).collect(),
-            ast,
+    fn parse_file_with_contents(&self, uri: &LspUrl, content: String) -> LspEvalResult {
+        match uri {
+            LspUrl::File(uri) => {
+                let EvalResult { messages, ast } =
+                    self.file_with_contents(&uri.to_string_lossy(), content);
+                LspEvalResult {
+                    diagnostics: messages.map(Diagnostic::from).collect(),
+                    ast,
+                }
+            }
+            _ => LspEvalResult::default(),
         }
     }
 
-    fn resolve_load(&self, path: &str, current_file: &Path) -> anyhow::Result<Url> {
+    fn resolve_load(&self, path: &str, current_file: &LspUrl) -> anyhow::Result<LspUrl> {
         let path = PathBuf::from(path);
-        let current_file_dir = current_file.parent();
-        let absolute_path = match (current_file_dir, path.is_absolute()) {
-            (_, true) => Ok(path),
-            (Some(current_file_dir), false) => Ok(current_file_dir.join(&path)),
-            (None, false) => Err(ResolveLoadError::MissingCurrentFilePath(path)),
-        }?;
-        Ok(Url::from_file_path(absolute_path).unwrap())
+        match current_file {
+            LspUrl::File(current_file_path) => {
+                let current_file_dir = current_file_path.parent();
+                let absolute_path = match (current_file_dir, path.is_absolute()) {
+                    (_, true) => Ok(path),
+                    (Some(current_file_dir), false) => Ok(current_file_dir.join(&path)),
+                    (None, false) => Err(ResolveLoadError::MissingCurrentFilePath(path)),
+                }?;
+                Ok(Url::from_file_path(absolute_path).unwrap().try_into()?)
+            }
+            _ => Err(
+                ResolveLoadError::WrongScheme("file://".to_owned(), current_file.clone()).into(),
+            ),
+        }
     }
 
     fn resolve_string_literal(
         &self,
         literal: &str,
-        current_file: &Path,
+        current_file: &LspUrl,
     ) -> anyhow::Result<Option<StringLiteralResult>> {
         self.resolve_load(literal, current_file).map(|url| {
             Some(StringLiteralResult {
@@ -242,20 +256,22 @@ impl LspContext for Context {
         })
     }
 
-    fn get_load_contents(&self, uri: &Url) -> anyhow::Result<Option<String>> {
-        let path = PathBuf::from(uri.path());
-        match path.is_absolute() {
-            true => match fs::read_to_string(&path) {
-                Ok(contents) => Ok(Some(contents)),
-                Err(e)
-                    if e.kind() == io::ErrorKind::NotFound
-                        || e.kind() == io::ErrorKind::NotADirectory =>
-                {
-                    Ok(None)
-                }
-                Err(e) => Err(e.into()),
+    fn get_load_contents(&self, uri: &LspUrl) -> anyhow::Result<Option<String>> {
+        match uri {
+            LspUrl::File(path) => match path.is_absolute() {
+                true => match fs::read_to_string(&path) {
+                    Ok(contents) => Ok(Some(contents)),
+                    Err(e)
+                        if e.kind() == io::ErrorKind::NotFound
+                            || e.kind() == io::ErrorKind::NotADirectory =>
+                    {
+                        Ok(None)
+                    }
+                    Err(e) => Err(e.into()),
+                },
+                false => Err(LoadContentsError::NotAbsolute(uri.clone()).into()),
             },
-            false => Err(LoadContentsError::NotAbsolute(uri.clone()).into()),
+            _ => Err(LoadContentsError::WrongScheme("file://".to_owned(), uri.clone()).into()),
         }
     }
 }

starlark/src/analysis/types.rs

@@ -17,6 +17,7 @@
 
 use std::fmt;
 use std::fmt::Display;
+use std::path::Path;
 
 use gazebo::prelude::*;
 use gazebo::variants::VariantName;
@@ -160,7 +161,7 @@ impl Display for EvalMessage {
 
 impl EvalMessage {
     /// Convert from an `anyhow::Error`, including some type checking, to an `EvalMessage`
-    pub fn from_anyhow(file: &str, x: &anyhow::Error) -> Self {
+    pub fn from_anyhow(file: &Path, x: &anyhow::Error) -> Self {
         match x.downcast_ref::<StarlarkDiagnostic>() {
             Some(
                 d @ StarlarkDiagnostic {
@@ -182,7 +183,7 @@ impl EvalMessage {
                 }
             }
             _ => Self {
-                path: file.to_owned(),
+                path: file.display().to_string(),
                 span: None,
                 severity: EvalSeverity::Error,
                 name: "error".to_owned(),