Virtual Entries in Component Browser

app/gui/Cargo.toml

@@ -38,6 +38,7 @@ parser = { path = "language/parser" }
 span-tree = { path = "language/span-tree" }
 bimap = { version = "0.4.0" }
 console_error_panic_hook = { version = "0.1.6" }
+const_format = { version = "0.2.22" }
 convert_case = { version = "0.5.0" }
 failure = { version = "0.1.6" }
 flo_stream = { version = "0.4.0" }

app/gui/controller/double-representation/Cargo.toml

@@ -16,6 +16,7 @@ enso-logger = { path = "../../../../lib/rust/logger" }
 enso-prelude = { path = "../../../../lib/rust/prelude" }
 enso-profiler = { path = "../../../../lib/rust/profiler" }
 enso-text = { path = "../../../../lib/rust/text" }
+const_format = { version = "0.2.22" }
 failure = { version = "0.1.6" }
 itertools = { version = "0.10.0" }
 serde = { version = "1.0", features = ["derive"] }

app/gui/controller/double-representation/src/project.rs

@@ -4,11 +4,27 @@ use crate::prelude::*;
 
 use crate::identifier::ReferentName;
 
+use const_format::concatcp;
 use serde::Deserialize;
 use serde::Serialize;
 
 
 
+// =================
+// === Constants ===
+// =================
+
+/// The namespace of the standard library.
+pub const STANDARD_NAMESPACE: &str = "Standard";
+
+/// The name of the project in the [`STANDARD_NAMESPACE`] containing the base standard library.
+pub const BASE_LIBRARY_NAME: &str = "Base";
+
+/// The full path of the [`BASE_LIBRARY_NAME`] project in the [`STANDARD_NAMESPACE`].
+pub const STANDARD_BASE_LIBRARY_PATH: &str = concatcp!(STANDARD_NAMESPACE, ".", BASE_LIBRARY_NAME);
+
+
+
 // ==============
 // === Errors ===
 // ==============
@@ -76,6 +92,12 @@ impl QualifiedName {
         }
     }
 
+    /// Return the fully qualified name of the [`BASE_LIBRARY_NAME`] project in the
+    /// [`STANDARD_NAMESPACE`].
+    pub fn standard_base_library() -> Self {
+        Self::from_segments(STANDARD_NAMESPACE, BASE_LIBRARY_NAME).unwrap()
+    }
+
     /// The iterator over name's segments: the namespace and project name.
     pub fn segments(&self) -> impl Iterator<Item = &str> {
         std::iter::once(self.namespace.as_ref()).chain(std::iter::once(self.project.as_ref()))
@@ -152,4 +174,9 @@ mod test {
         invalid_case("namespace.");
         invalid_case(".");
     }
+
+    #[test]
+    fn qualified_name_of_standard_base_library_does_not_panic() {
+        let _ = QualifiedName::standard_base_library();
+    }
 }

app/gui/src/controller/searcher.rs

@@ -13,6 +13,7 @@ use crate::model::suggestion_database;
 use crate::model::suggestion_database::entry::CodeToInsert;
 use crate::notification;
 
+use const_format::concatcp;
 use double_representation::graph::GraphInfo;
 use double_representation::graph::LocationHint;
 use double_representation::module::QualifiedName;
@@ -47,7 +48,9 @@ pub const ASSIGN_NAMES_FOR_NODES: bool = true;
 
 /// The special module used for mock `Enso_Project.data` entry.
 /// See also [`Searcher::add_enso_project_entries`].
-const ENSO_PROJECT_SPECIAL_MODULE: &str = "Standard.Base.Enso_Project";
+const ENSO_PROJECT_SPECIAL_MODULE: &str =
+    concatcp!(project::STANDARD_BASE_LIBRARY_PATH, ".Enso_Project");
+
 
 
 // ==============
@@ -1188,6 +1191,10 @@ fn component_list_builder_with_favorites<'a>(
         builder = builder.with_local_scope_module_id(id);
     }
     builder.set_grouping_and_order_of_favorites(suggestion_db, groups);
+    let base_lib_qn = project::QualifiedName::standard_base_library();
+    let input_group_name = component::hardcoded::INPUT_GROUP_NAME;
+    let snippets = component::hardcoded::INPUT_SNIPPETS.with(|s| s.clone());
+    builder.insert_virtual_components_in_favorites_group(input_group_name, base_lib_qn, snippets);
     builder
 }
 
@@ -1786,7 +1793,7 @@ pub mod test {
         // Prepare a sample component group to be returned by a mock Language Server client.
         let module_qualified_name = crate::test::mock::data::module_qualified_name().to_string();
         let sample_ls_component_group = language_server::LibraryComponentGroup {
-            library: "".to_string(),
+            library: project::QualifiedName::standard_base_library().to_string(),
             name:    "Test Group 1".to_string(),
             color:   None,
             icon:    None,
@@ -1819,17 +1826,19 @@ pub mod test {
                 format!("{}.{}", entry1.module.project_name.project, entry1.module.name());
             assert_eq!(module_group.name, expected_group_name);
             let entries = module_group.entries.borrow();
-            assert_matches!(entries.as_slice(), [e1, e2] if e1.suggestion.name == entry1.name && e2.suggestion.name == entry9.name);
+            assert_matches!(entries.as_slice(), [e1, e2] if e1.name() == entry1.name && e2.name() == entry9.name);
         } else {
             ipanic!("Wrong top modules in Component List: {components.top_modules():?}");
         }
         let favorites = &components.favorites;
-        assert_eq!(favorites.len(), 1);
-        let favorites_group = &favorites[0];
-        assert_eq!(favorites_group.name, "Test Group 1");
-        let favorites_entries = favorites_group.entries.borrow();
+        assert_eq!(favorites.len(), 2);
+        let favorites_group_0 = &favorites[0];
+        assert_eq!(favorites_group_0.name, component::hardcoded::INPUT_GROUP_NAME);
+        let favorites_group_1 = &favorites[1];
+        assert_eq!(favorites_group_1.name, "Test Group 1");
+        let favorites_entries = favorites_group_1.entries.borrow();
         assert_eq!(favorites_entries.len(), 1);
-        assert_eq!(*favorites_entries[0].id, 1);
+        assert_eq!(favorites_entries[0].id().unwrap(), 1);
     }
 
     #[wasm_bindgen_test]

app/gui/src/controller/searcher/action.rs

@@ -57,10 +57,11 @@ impl Suggestion {
 
     /// Return the documentation assigned to the suggestion.
     pub fn documentation_html(&self) -> Option<&str> {
-        match self {
-            Suggestion::FromDatabase(s) => s.documentation_html.as_ref().map(AsRef::<str>::as_ref),
-            Suggestion::Hardcoded(s) => s.documentation_html,
-        }
+        let doc_html = match self {
+            Suggestion::FromDatabase(s) => &s.documentation_html,
+            Suggestion::Hardcoded(s) => &s.documentation_html,
+        };
+        doc_html.as_ref().map(AsRef::<str>::as_ref)
     }
 
     /// The Id of the method called by a suggestion, or [`None`] if the suggestion is not a method

app/gui/src/controller/searcher/action/hardcoded.rs

@@ -102,15 +102,16 @@ pub struct Suggestion {
     /// An import required by the suggestion.
     pub imports:            Vec<module::QualifiedName>,
     /// The documentation bound to the suggestion.
-    pub documentation_html: Option<&'static str>,
+    pub documentation_html: Option<String>,
     /// The id of the method called by the suggestion.
     pub method_id:          Option<MethodId>,
     /// The name of the icon bound to this entry.
     pub icon:               ImString,
 }
 
 impl Suggestion {
-    fn new(name: &'static str, code: &'static str, icon: &ImString) -> Self {
+    /// Construct a suggestion with given name, code, and icon.
+    pub(crate) fn new(name: &'static str, code: &'static str, icon: &ImString) -> Self {
         let icon = icon.clone_ref();
         Self { name, code, icon, ..default() }
     }
@@ -130,7 +131,10 @@ impl Suggestion {
         self
     }
 
-    fn with_return_type(
+    /// Returns a modified suggestion with [`Suggestion::return_type`] field set. This method is
+    /// only intended to be used when defining hardcoded suggestions and panics if the argument
+    /// fails to convert to a valid type name.
+    pub(crate) fn with_return_type(
         mut self,
         return_type: impl TryInto<tp::QualifiedName, Error: Debug>,
     ) -> Self {
@@ -146,6 +150,18 @@ impl Suggestion {
         self
     }
 
+    /// Returns a modified suggestion with [`Suggestion::documentation_html`] field set. This
+    /// method is only intended to be used when defining hardcoded suggestions and panics if a
+    /// documentation parser cannot be created or the argument fails to parse as valid
+    /// documentation.
+    pub(crate) fn with_documentation(mut self, documentation: &str) -> Self {
+        let doc_parser = parser::DocParser::new().unwrap();
+        let doc_string = documentation.to_string();
+        let documentation_html = doc_parser.generate_html_doc_pure(doc_string);
+        self.documentation_html = Some(documentation_html.unwrap());
+        self
+    }
+
     fn marked_as_method_call(
         mut self,
         name: &'static str,

app/gui/src/controller/searcher/component.rs

@@ -16,6 +16,7 @@ use convert_case::Casing;
 
 pub mod builder;
 pub mod group;
+pub mod hardcoded;
 
 pub use group::Group;
 
@@ -54,6 +55,31 @@ pub enum Order {
 
 
 
+// ============
+// === Data ===
+// ============
+
+/// Contains detailed data of a [`Component`]. The storage of the details differs depending on
+/// where the data originates from (either from the [`suggestion_database`] or from a
+/// [`hardcoded::Snippet`]).
+#[derive(Clone, CloneRef, Debug)]
+pub enum Data {
+    /// A component from the [`suggestion_database`].
+    FromDatabase {
+        /// The ID of the component in the [`suggestion_database`].
+        id:    Immutable<Id>,
+        /// The component's entry in the [`suggestion_database`].
+        entry: Rc<suggestion_database::Entry>,
+    },
+    /// A virtual component containing a hardcoded snippet of code.
+    Virtual {
+        /// A hardcoded snippet of code.
+        snippet: Rc<hardcoded::Snippet>,
+    },
+}
+
+
+
 // =================
 // === Component ===
 // =================
@@ -69,24 +95,40 @@ pub enum Order {
 #[allow(missing_docs)]
 #[derive(Clone, CloneRef, Debug)]
 pub struct Component {
-    pub id:         Immutable<Id>,
-    pub suggestion: Rc<suggestion_database::Entry>,
+    pub data:       Data,
     pub match_info: Rc<RefCell<MatchInfo>>,
 }
 
 impl Component {
-    /// Construct a new component.
+    /// Construct a new component from a [`suggestion_database`] entry.
     ///
     /// The matching info will be filled for an empty pattern.
-    pub fn new(id: Id, suggestion: Rc<suggestion_database::Entry>) -> Self {
-        Self { id: Immutable(id), suggestion, match_info: default() }
+    pub fn new_from_database_entry(id: Id, entry: Rc<suggestion_database::Entry>) -> Self {
+        let data = Data::FromDatabase { id: Immutable(id), entry };
+        Self { data, match_info: default() }
     }
 
     /// The label which should be displayed in the Component Browser.
     pub fn label(&self) -> String {
         self.to_string()
     }
 
+    /// The name of the component.
+    pub fn name(&self) -> &str {
+        match &self.data {
+            Data::FromDatabase { entry, .. } => entry.name.as_str(),
+            Data::Virtual { snippet } => snippet.name,
+        }
+    }
+
+    /// The [`Id`] of the component in the [`suggestion_database`], or `None` if not applicable.
+    pub fn id(&self) -> Option<Id> {
+        match self.data {
+            Data::FromDatabase { id, .. } => Some(*id),
+            Data::Virtual { .. } => None,
+        }
+    }
+
     /// Checks if component is filtered out.
     pub fn is_filtered_out(&self) -> bool {
         matches!(*self.match_info.borrow(), MatchInfo::DoesNotMatch)
@@ -97,7 +139,8 @@ impl Component {
     /// Currently, only modules can be entered, and then the Browser should display content and
     /// submodules of the entered module.
     pub fn can_be_entered(&self) -> bool {
-        self.suggestion.kind == suggestion_database::entry::Kind::Module
+        use suggestion_database::entry::Kind as EntryKind;
+        matches!(&self.data, Data::FromDatabase { entry, .. } if entry.kind == EntryKind::Module)
     }
 
     /// Update matching info.
@@ -117,16 +160,27 @@ impl Component {
     }
 }
 
+impl From<Rc<hardcoded::Snippet>> for Component {
+    fn from(snippet: Rc<hardcoded::Snippet>) -> Self {
+        Self { data: Data::Virtual { snippet }, match_info: default() }
+    }
+}
+
 impl Display for Component {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let self_type_not_here =
-            self.suggestion.self_type.as_ref().filter(|t| *t != &self.suggestion.module);
-        if let Some(self_type) = self_type_not_here {
-            let self_name = self_type.name.from_case(Case::Snake).to_case(Case::Title);
-            let name = self.suggestion.name.from_case(Case::Snake).to_case(Case::Lower);
-            write!(f, "{} {}", self_name, name)
-        } else {
-            write!(f, "{}", self.suggestion.name.from_case(Case::Snake).to_case(Case::Lower))
+        match &self.data {
+            Data::FromDatabase { entry, .. } => {
+                let entry_name = entry.name.from_case(Case::Snake).to_case(Case::Lower);
+                let self_type_ref = entry.self_type.as_ref();
+                let self_type_not_here = self_type_ref.filter(|t| *t != &entry.module);
+                if let Some(self_type) = self_type_not_here {
+                    let self_name = self_type.name.from_case(Case::Snake).to_case(Case::Title);
+                    write!(f, "{} {}", self_name, entry_name)
+                } else {
+                    write!(f, "{}", entry_name)
+                }
+            }
+            Data::Virtual { snippet } => write!(f, "{}", snippet.name),
         }
     }
 }
@@ -240,6 +294,7 @@ pub(crate) mod tests {
     use crate::model::suggestion_database::entry::Kind;
 
     use double_representation::module;
+    use double_representation::project;
     use engine_protocol::language_server;
 
 
@@ -312,6 +367,7 @@ pub(crate) mod tests {
     ) -> Vec<crate::model::execution_context::ComponentGroup> {
         let db_entries = component_ids.iter().map(|id| db.lookup(*id).unwrap());
         let group = crate::model::execution_context::ComponentGroup {
+            project:    project::QualifiedName::standard_base_library(),
             name:       "Test Group 1".into(),
             color:      None,
             components: db_entries.into_iter().map(|e| e.qualified_name()).collect(),
@@ -331,7 +387,7 @@ pub(crate) mod tests {
             .borrow()
             .iter()
             .take_while(|c| matches!(*c.match_info.borrow(), MatchInfo::Matches { .. }))
-            .map(|c| *c.id)
+            .map(|c| c.id().unwrap())
             .collect_vec();
         assert_eq!(ids_of_matches, expected_ids);
     }
@@ -408,7 +464,7 @@ pub(crate) mod tests {
         // ("test.Test.TopModule1.SubModule2").
         let content = list.get_module_content(3).unwrap();
         let expected_content_ids = vec![9, 4];
-        let content_ids = content.entries.borrow().iter().map(|entry| *entry.id).collect_vec();
+        let content_ids = content.entries.borrow().iter().map(|e| e.id().unwrap()).collect_vec();
         assert_eq!(content_ids, expected_content_ids);
         let direct_submodules = list.submodules_of(3).unwrap();
         let expected_direct_submodules_ids = vec![Some(4)];
@@ -419,7 +475,7 @@ pub(crate) mod tests {
         // ("test.Test.TopModule1.SubModule1.SubSubModule").
         let content = list.get_module_content(4).unwrap();
         let expected_content_ids = vec![10];
-        let content_ids = content.entries.borrow().iter().map(|entry| *entry.id).collect_vec();
+        let content_ids = content.entries.borrow().iter().map(|e| e.id().unwrap()).collect_vec();
         assert_eq!(content_ids, expected_content_ids);
     }
 }